clang 20.0.0git
SemaPPC.cpp
Go to the documentation of this file.
1//===------ SemaPPC.cpp ------ PowerPC target-specific routines -----------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements semantic analysis functions specific to PowerPC.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/Sema/SemaPPC.h"
15#include "clang/AST/Attr.h"
16#include "clang/AST/CharUnits.h"
17#include "clang/AST/Decl.h"
18#include "clang/AST/Type.h"
23#include "clang/Sema/Sema.h"
24#include "llvm/ADT/APSInt.h"
25
26namespace clang {
27
29
31 const auto *ICE = dyn_cast<ImplicitCastExpr>(Arg->IgnoreParens());
32 if (!ICE)
33 return;
34
35 const auto *DR = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
36 if (!DR)
37 return;
38
39 const auto *PD = dyn_cast<ParmVarDecl>(DR->getDecl());
40 if (!PD || !PD->getType()->isRecordType())
41 return;
42
43 QualType ArgType = Arg->getType();
44 for (const FieldDecl *FD :
45 ArgType->castAs<RecordType>()->getDecl()->fields()) {
46 if (const auto *AA = FD->getAttr<AlignedAttr>()) {
48 AA->getAlignment(getASTContext()));
49 if (Alignment.getQuantity() == 16) {
50 Diag(FD->getLocation(), diag::warn_not_xl_compatible) << FD;
51 Diag(Loc, diag::note_misaligned_member_used_here) << PD;
52 }
53 }
54 }
55}
56
57static bool isPPC_64Builtin(unsigned BuiltinID) {
58 // These builtins only work on PPC 64bit targets.
59 switch (BuiltinID) {
60 case PPC::BI__builtin_divde:
61 case PPC::BI__builtin_divdeu:
62 case PPC::BI__builtin_bpermd:
63 case PPC::BI__builtin_pdepd:
64 case PPC::BI__builtin_pextd:
65 case PPC::BI__builtin_ppc_cdtbcd:
66 case PPC::BI__builtin_ppc_cbcdtd:
67 case PPC::BI__builtin_ppc_addg6s:
68 case PPC::BI__builtin_ppc_ldarx:
69 case PPC::BI__builtin_ppc_stdcx:
70 case PPC::BI__builtin_ppc_tdw:
71 case PPC::BI__builtin_ppc_trapd:
72 case PPC::BI__builtin_ppc_cmpeqb:
73 case PPC::BI__builtin_ppc_setb:
74 case PPC::BI__builtin_ppc_mulhd:
75 case PPC::BI__builtin_ppc_mulhdu:
76 case PPC::BI__builtin_ppc_maddhd:
77 case PPC::BI__builtin_ppc_maddhdu:
78 case PPC::BI__builtin_ppc_maddld:
79 case PPC::BI__builtin_ppc_load8r:
80 case PPC::BI__builtin_ppc_store8r:
81 case PPC::BI__builtin_ppc_insert_exp:
82 case PPC::BI__builtin_ppc_extract_sig:
83 case PPC::BI__builtin_ppc_addex:
84 case PPC::BI__builtin_darn:
85 case PPC::BI__builtin_darn_raw:
86 case PPC::BI__builtin_ppc_compare_and_swaplp:
87 case PPC::BI__builtin_ppc_fetch_and_addlp:
88 case PPC::BI__builtin_ppc_fetch_and_andlp:
89 case PPC::BI__builtin_ppc_fetch_and_orlp:
90 case PPC::BI__builtin_ppc_fetch_and_swaplp:
91 return true;
92 }
93 return false;
94}
95
97 unsigned BuiltinID,
98 CallExpr *TheCall) {
99 ASTContext &Context = getASTContext();
100 bool IsTarget64Bit = TI.getTypeWidth(TI.getIntPtrType()) == 64;
101 llvm::APSInt Result;
102
103 if (isPPC_64Builtin(BuiltinID) && !IsTarget64Bit)
104 return Diag(TheCall->getBeginLoc(), diag::err_64_bit_builtin_32_bit_tgt)
105 << TheCall->getSourceRange();
106
107 switch (BuiltinID) {
108 default:
109 return false;
110 case PPC::BI__builtin_altivec_crypto_vshasigmaw:
111 case PPC::BI__builtin_altivec_crypto_vshasigmad:
112 return SemaRef.BuiltinConstantArgRange(TheCall, 1, 0, 1) ||
113 SemaRef.BuiltinConstantArgRange(TheCall, 2, 0, 15);
114 case PPC::BI__builtin_altivec_dss:
115 return SemaRef.BuiltinConstantArgRange(TheCall, 0, 0, 3);
116 case PPC::BI__builtin_tbegin:
117 case PPC::BI__builtin_tend:
118 return SemaRef.BuiltinConstantArgRange(TheCall, 0, 0, 1);
119 case PPC::BI__builtin_tsr:
120 return SemaRef.BuiltinConstantArgRange(TheCall, 0, 0, 7);
121 case PPC::BI__builtin_tabortwc:
122 case PPC::BI__builtin_tabortdc:
123 return SemaRef.BuiltinConstantArgRange(TheCall, 0, 0, 31);
124 case PPC::BI__builtin_tabortwci:
125 case PPC::BI__builtin_tabortdci:
126 return SemaRef.BuiltinConstantArgRange(TheCall, 0, 0, 31) ||
127 SemaRef.BuiltinConstantArgRange(TheCall, 2, 0, 31);
128 // According to GCC 'Basic PowerPC Built-in Functions Available on ISA 2.05',
129 // __builtin_(un)pack_longdouble are available only if long double uses IBM
130 // extended double representation.
131 case PPC::BI__builtin_unpack_longdouble:
132 if (SemaRef.BuiltinConstantArgRange(TheCall, 1, 0, 1))
133 return true;
134 [[fallthrough]];
135 case PPC::BI__builtin_pack_longdouble:
136 if (&TI.getLongDoubleFormat() != &llvm::APFloat::PPCDoubleDouble())
137 return Diag(TheCall->getBeginLoc(), diag::err_ppc_builtin_requires_abi)
138 << "ibmlongdouble";
139 return false;
140 case PPC::BI__builtin_altivec_dst:
141 case PPC::BI__builtin_altivec_dstt:
142 case PPC::BI__builtin_altivec_dstst:
143 case PPC::BI__builtin_altivec_dststt:
144 return SemaRef.BuiltinConstantArgRange(TheCall, 2, 0, 3);
145 case PPC::BI__builtin_vsx_xxpermdi:
146 case PPC::BI__builtin_vsx_xxsldwi:
147 return BuiltinVSX(TheCall);
148 case PPC::BI__builtin_unpack_vector_int128:
149 return SemaRef.BuiltinConstantArgRange(TheCall, 1, 0, 1);
150 case PPC::BI__builtin_altivec_vgnb:
151 return SemaRef.BuiltinConstantArgRange(TheCall, 1, 2, 7);
152 case PPC::BI__builtin_vsx_xxeval:
153 return SemaRef.BuiltinConstantArgRange(TheCall, 3, 0, 255);
154 case PPC::BI__builtin_altivec_vsldbi:
155 return SemaRef.BuiltinConstantArgRange(TheCall, 2, 0, 7);
156 case PPC::BI__builtin_altivec_vsrdbi:
157 return SemaRef.BuiltinConstantArgRange(TheCall, 2, 0, 7);
158 case PPC::BI__builtin_vsx_xxpermx:
159 return SemaRef.BuiltinConstantArgRange(TheCall, 3, 0, 7);
160 case PPC::BI__builtin_ppc_tw:
161 case PPC::BI__builtin_ppc_tdw:
162 return SemaRef.BuiltinConstantArgRange(TheCall, 2, 1, 31);
163 case PPC::BI__builtin_ppc_cmprb:
164 return SemaRef.BuiltinConstantArgRange(TheCall, 0, 0, 1);
165 // For __rlwnm, __rlwimi and __rldimi, the last parameter mask must
166 // be a constant that represents a contiguous bit field.
167 case PPC::BI__builtin_ppc_rlwnm:
168 return SemaRef.ValueIsRunOfOnes(TheCall, 2);
169 case PPC::BI__builtin_ppc_rlwimi:
170 return SemaRef.BuiltinConstantArgRange(TheCall, 2, 0, 31) ||
171 SemaRef.ValueIsRunOfOnes(TheCall, 3);
172 case PPC::BI__builtin_ppc_rldimi:
173 return SemaRef.BuiltinConstantArgRange(TheCall, 2, 0, 63) ||
174 SemaRef.ValueIsRunOfOnes(TheCall, 3);
175 case PPC::BI__builtin_ppc_addex: {
176 if (SemaRef.BuiltinConstantArgRange(TheCall, 2, 0, 3))
177 return true;
178 // Output warning for reserved values 1 to 3.
179 int ArgValue =
180 TheCall->getArg(2)->getIntegerConstantExpr(Context)->getSExtValue();
181 if (ArgValue != 0)
182 Diag(TheCall->getBeginLoc(), diag::warn_argument_undefined_behaviour)
183 << ArgValue;
184 return false;
185 }
186 case PPC::BI__builtin_ppc_mtfsb0:
187 case PPC::BI__builtin_ppc_mtfsb1:
188 return SemaRef.BuiltinConstantArgRange(TheCall, 0, 0, 31);
189 case PPC::BI__builtin_ppc_mtfsf:
190 return SemaRef.BuiltinConstantArgRange(TheCall, 0, 0, 255);
191 case PPC::BI__builtin_ppc_mtfsfi:
192 return SemaRef.BuiltinConstantArgRange(TheCall, 0, 0, 7) ||
193 SemaRef.BuiltinConstantArgRange(TheCall, 1, 0, 15);
194 case PPC::BI__builtin_ppc_alignx:
195 return SemaRef.BuiltinConstantArgPower2(TheCall, 0);
196 case PPC::BI__builtin_ppc_rdlam:
197 return SemaRef.ValueIsRunOfOnes(TheCall, 2);
198 case PPC::BI__builtin_vsx_ldrmb:
199 case PPC::BI__builtin_vsx_strmb:
200 return SemaRef.BuiltinConstantArgRange(TheCall, 1, 1, 16);
201 case PPC::BI__builtin_altivec_vcntmbb:
202 case PPC::BI__builtin_altivec_vcntmbh:
203 case PPC::BI__builtin_altivec_vcntmbw:
204 case PPC::BI__builtin_altivec_vcntmbd:
205 return SemaRef.BuiltinConstantArgRange(TheCall, 1, 0, 1);
206 case PPC::BI__builtin_vsx_xxgenpcvbm:
207 case PPC::BI__builtin_vsx_xxgenpcvhm:
208 case PPC::BI__builtin_vsx_xxgenpcvwm:
209 case PPC::BI__builtin_vsx_xxgenpcvdm:
210 return SemaRef.BuiltinConstantArgRange(TheCall, 1, 0, 3);
211 case PPC::BI__builtin_ppc_test_data_class: {
212 // Check if the first argument of the __builtin_ppc_test_data_class call is
213 // valid. The argument must be 'float' or 'double' or '__float128'.
214 QualType ArgType = TheCall->getArg(0)->getType();
215 if (ArgType != QualType(Context.FloatTy) &&
216 ArgType != QualType(Context.DoubleTy) &&
217 ArgType != QualType(Context.Float128Ty))
218 return Diag(TheCall->getBeginLoc(),
219 diag::err_ppc_invalid_test_data_class_type);
220 return SemaRef.BuiltinConstantArgRange(TheCall, 1, 0, 127);
221 }
222 case PPC::BI__builtin_ppc_maxfe:
223 case PPC::BI__builtin_ppc_minfe:
224 case PPC::BI__builtin_ppc_maxfl:
225 case PPC::BI__builtin_ppc_minfl:
226 case PPC::BI__builtin_ppc_maxfs:
227 case PPC::BI__builtin_ppc_minfs: {
228 if (Context.getTargetInfo().getTriple().isOSAIX() &&
229 (BuiltinID == PPC::BI__builtin_ppc_maxfe ||
230 BuiltinID == PPC::BI__builtin_ppc_minfe))
231 return Diag(TheCall->getBeginLoc(), diag::err_target_unsupported_type)
232 << "builtin" << true << 128 << QualType(Context.LongDoubleTy)
233 << false << Context.getTargetInfo().getTriple().str();
234 // Argument type should be exact.
235 QualType ArgType = QualType(Context.LongDoubleTy);
236 if (BuiltinID == PPC::BI__builtin_ppc_maxfl ||
237 BuiltinID == PPC::BI__builtin_ppc_minfl)
238 ArgType = QualType(Context.DoubleTy);
239 else if (BuiltinID == PPC::BI__builtin_ppc_maxfs ||
240 BuiltinID == PPC::BI__builtin_ppc_minfs)
241 ArgType = QualType(Context.FloatTy);
242 for (unsigned I = 0, E = TheCall->getNumArgs(); I < E; ++I)
243 if (TheCall->getArg(I)->getType() != ArgType)
244 return Diag(TheCall->getBeginLoc(),
245 diag::err_typecheck_convert_incompatible)
246 << TheCall->getArg(I)->getType() << ArgType << 1 << 0 << 0;
247 return false;
248 }
249#define CUSTOM_BUILTIN(Name, Intr, Types, Acc, Feature) \
250 case PPC::BI__builtin_##Name: \
251 return BuiltinPPCMMACall(TheCall, BuiltinID, Types);
252#include "clang/Basic/BuiltinsPPC.def"
253 }
254 llvm_unreachable("must return from switch");
255}
256
257// Check if the given type is a non-pointer PPC MMA type. This function is used
258// in Sema to prevent invalid uses of restricted PPC MMA types.
260 ASTContext &Context = getASTContext();
261 if (Type->isPointerType() || Type->isArrayType())
262 return false;
263
264 QualType CoreType = Type.getCanonicalType().getUnqualifiedType();
265#define PPC_VECTOR_TYPE(Name, Id, Size) || CoreType == Context.Id##Ty
266 if (false
267#include "clang/Basic/PPCTypes.def"
268 ) {
269 Diag(TypeLoc, diag::err_ppc_invalid_use_mma_type);
270 return true;
271 }
272 return false;
273}
274
275/// DecodePPCMMATypeFromStr - This decodes one PPC MMA type descriptor from Str,
276/// advancing the pointer over the consumed characters. The decoded type is
277/// returned. If the decoded type represents a constant integer with a
278/// constraint on its value then Mask is set to that value. The type descriptors
279/// used in Str are specific to PPC MMA builtins and are documented in the file
280/// defining the PPC builtins.
281static QualType DecodePPCMMATypeFromStr(ASTContext &Context, const char *&Str,
282 unsigned &Mask) {
283 bool RequireICE = false;
285 switch (*Str++) {
286 case 'V':
287 return Context.getVectorType(Context.UnsignedCharTy, 16,
289 case 'i': {
290 char *End;
291 unsigned size = strtoul(Str, &End, 10);
292 assert(End != Str && "Missing constant parameter constraint");
293 Str = End;
294 Mask = size;
295 return Context.IntTy;
296 }
297 case 'W': {
298 char *End;
299 unsigned size = strtoul(Str, &End, 10);
300 assert(End != Str && "Missing PowerPC MMA type size");
301 Str = End;
303 switch (size) {
304#define PPC_VECTOR_TYPE(typeName, Id, size) \
305 case size: \
306 Type = Context.Id##Ty; \
307 break;
308#include "clang/Basic/PPCTypes.def"
309 default:
310 llvm_unreachable("Invalid PowerPC MMA vector type");
311 }
312 bool CheckVectorArgs = false;
313 while (!CheckVectorArgs) {
314 switch (*Str++) {
315 case '*':
316 Type = Context.getPointerType(Type);
317 break;
318 case 'C':
319 Type = Type.withConst();
320 break;
321 default:
322 CheckVectorArgs = true;
323 --Str;
324 break;
325 }
326 }
327 return Type;
328 }
329 default:
330 return Context.DecodeTypeStr(--Str, Context, Error, RequireICE, true);
331 }
332}
333
334bool SemaPPC::BuiltinPPCMMACall(CallExpr *TheCall, unsigned BuiltinID,
335 const char *TypeStr) {
336
337 assert((TypeStr[0] != '\0') &&
338 "Invalid types in PPC MMA builtin declaration");
339
340 ASTContext &Context = getASTContext();
341 unsigned Mask = 0;
342 unsigned ArgNum = 0;
343
344 // The first type in TypeStr is the type of the value returned by the
345 // builtin. So we first read that type and change the type of TheCall.
346 QualType type = DecodePPCMMATypeFromStr(Context, TypeStr, Mask);
347 TheCall->setType(type);
348
349 while (*TypeStr != '\0') {
350 Mask = 0;
351 QualType ExpectedType = DecodePPCMMATypeFromStr(Context, TypeStr, Mask);
352 if (ArgNum >= TheCall->getNumArgs()) {
353 ArgNum++;
354 break;
355 }
356
357 Expr *Arg = TheCall->getArg(ArgNum);
358 QualType PassedType = Arg->getType();
359 QualType StrippedRVType = PassedType.getCanonicalType();
360
361 // Strip Restrict/Volatile qualifiers.
362 if (StrippedRVType.isRestrictQualified() ||
363 StrippedRVType.isVolatileQualified())
364 StrippedRVType = StrippedRVType.getCanonicalType().getUnqualifiedType();
365
366 // The only case where the argument type and expected type are allowed to
367 // mismatch is if the argument type is a non-void pointer (or array) and
368 // expected type is a void pointer.
369 if (StrippedRVType != ExpectedType)
370 if (!(ExpectedType->isVoidPointerType() &&
371 (StrippedRVType->isPointerType() || StrippedRVType->isArrayType())))
372 return Diag(Arg->getBeginLoc(),
373 diag::err_typecheck_convert_incompatible)
374 << PassedType << ExpectedType << 1 << 0 << 0;
375
376 // If the value of the Mask is not 0, we have a constraint in the size of
377 // the integer argument so here we ensure the argument is a constant that
378 // is in the valid range.
379 if (Mask != 0 &&
380 SemaRef.BuiltinConstantArgRange(TheCall, ArgNum, 0, Mask, true))
381 return true;
382
383 ArgNum++;
384 }
385
386 // In case we exited early from the previous loop, there are other types to
387 // read from TypeStr. So we need to read them all to ensure we have the right
388 // number of arguments in TheCall and if it is not the case, to display a
389 // better error message.
390 while (*TypeStr != '\0') {
391 (void)DecodePPCMMATypeFromStr(Context, TypeStr, Mask);
392 ArgNum++;
393 }
394 if (SemaRef.checkArgCount(TheCall, ArgNum))
395 return true;
396
397 return false;
398}
399
401 unsigned ExpectedNumArgs = 3;
402 if (SemaRef.checkArgCount(TheCall, ExpectedNumArgs))
403 return true;
404
405 // Check the third argument is a compile time constant
406 if (!TheCall->getArg(2)->isIntegerConstantExpr(getASTContext()))
407 return Diag(TheCall->getBeginLoc(),
408 diag::err_vsx_builtin_nonconstant_argument)
409 << 3 /* argument index */ << TheCall->getDirectCallee()
410 << SourceRange(TheCall->getArg(2)->getBeginLoc(),
411 TheCall->getArg(2)->getEndLoc());
412
413 QualType Arg1Ty = TheCall->getArg(0)->getType();
414 QualType Arg2Ty = TheCall->getArg(1)->getType();
415
416 // Check the type of argument 1 and argument 2 are vectors.
417 SourceLocation BuiltinLoc = TheCall->getBeginLoc();
418 if ((!Arg1Ty->isVectorType() && !Arg1Ty->isDependentType()) ||
419 (!Arg2Ty->isVectorType() && !Arg2Ty->isDependentType())) {
420 return Diag(BuiltinLoc, diag::err_vec_builtin_non_vector)
421 << TheCall->getDirectCallee() << /*isMorethantwoArgs*/ false
422 << SourceRange(TheCall->getArg(0)->getBeginLoc(),
423 TheCall->getArg(1)->getEndLoc());
424 }
425
426 // Check the first two arguments are the same type.
427 if (!getASTContext().hasSameUnqualifiedType(Arg1Ty, Arg2Ty)) {
428 return Diag(BuiltinLoc, diag::err_vec_builtin_incompatible_vector)
429 << TheCall->getDirectCallee() << /*isMorethantwoArgs*/ false
430 << SourceRange(TheCall->getArg(0)->getBeginLoc(),
431 TheCall->getArg(1)->getEndLoc());
432 }
433
434 // When default clang type checking is turned off and the customized type
435 // checking is used, the returning type of the function must be explicitly
436 // set. Otherwise it is _Bool by default.
437 TheCall->setType(Arg1Ty);
438
439 return false;
440}
441
442} // namespace clang
Defines the clang::ASTContext interface.
Expr * E
SourceLocation Loc
Definition: SemaObjC.cpp:759
This file declares semantic analysis functions specific to PowerPC.
Defines the clang::SourceLocation class and associated facilities.
Enumerates target-specific builtins in their own namespaces within namespace clang.
C Language Family Type Representation.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:188
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
CanQualType IntTy
Definition: ASTContext.h:1169
CanQualType UnsignedCharTy
Definition: ASTContext.h:1170
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
QualType DecodeTypeStr(const char *&Str, const ASTContext &Context, ASTContext::GetBuiltinTypeError &Error, bool &RequireICE, bool AllowTypeModifiers) const
@ GE_None
No error.
Definition: ASTContext.h:2384
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2874
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:3068
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.cpp:1638
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
Definition: Expr.h:3047
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:3055
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:185
This represents one expression.
Definition: Expr.h:110
void setType(QualType t)
Definition: Expr.h:143
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:3086
bool isIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
QualType getType() const
Definition: Expr.h:142
Represents a member of a struct/union/class.
Definition: Decl.h:3033
A (possibly-)qualified type.
Definition: Type.h:929
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:8015
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
Definition: Type.h:8009
QualType getCanonicalType() const
Definition: Type.h:7983
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:8025
field_range fields() const
Definition: Decl.h:4354
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:6072
RecordDecl * getDecl() const
Definition: Type.h:6082
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
Definition: SemaBase.cpp:60
ASTContext & getASTContext() const
Definition: SemaBase.cpp:9
Sema & SemaRef
Definition: SemaBase.h:40
bool CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, CallExpr *TheCall)
Definition: SemaPPC.cpp:96
void checkAIXMemberAlignment(SourceLocation Loc, const Expr *Arg)
Definition: SemaPPC.cpp:30
SemaPPC(Sema &S)
Definition: SemaPPC.cpp:28
bool BuiltinPPCMMACall(CallExpr *TheCall, unsigned BuiltinID, const char *TypeDesc)
BuiltinPPCMMACall - Check the call to a PPC MMA builtin for validity.
Definition: SemaPPC.cpp:334
bool BuiltinVSX(CallExpr *TheCall)
Definition: SemaPPC.cpp:400
bool CheckPPCMMAType(QualType Type, SourceLocation TypeLoc)
Definition: SemaPPC.cpp:259
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:463
bool ValueIsRunOfOnes(CallExpr *TheCall, unsigned ArgNum)
Returns true if the argument consists of one contiguous run of 1s with any number of 0s on either sid...
bool BuiltinConstantArgPower2(CallExpr *TheCall, int ArgNum)
BuiltinConstantArgPower2 - Check if argument ArgNum of TheCall is a constant expression representing ...
bool checkArgCount(CallExpr *Call, unsigned DesiredArgCount)
Checks that a call expression's argument count is the desired number.
bool BuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low, int High, bool RangeIsError=true)
BuiltinConstantArgRange - Handle a check if argument ArgNum of CallExpr TheCall is a constant express...
Encodes a location in the source.
A trivial tuple used to represent a source range.
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:348
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:324
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:336
Exposes information about the current target.
Definition: TargetInfo.h:220
unsigned getTypeWidth(IntType T) const
Return the width (in bits) of the specified integer type enum.
Definition: TargetInfo.cpp:286
IntType getIntPtrType() const
Definition: TargetInfo.h:396
const llvm::fltSemantics & getLongDoubleFormat() const
Definition: TargetInfo.h:788
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:59
The base class of the type hierarchy.
Definition: Type.h:1828
bool isArrayType() const
Definition: Type.h:8258
bool isPointerType() const
Definition: Type.h:8186
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:8800
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2706
bool isVectorType() const
Definition: Type.h:8298
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
The JSON file list parser is used to communicate input to InstallAPI.
static bool isPPC_64Builtin(unsigned BuiltinID)
Definition: SemaPPC.cpp:57
@ Result
The result type of a method or function.
static QualType DecodePPCMMATypeFromStr(ASTContext &Context, const char *&Str, unsigned &Mask)
DecodePPCMMATypeFromStr - This decodes one PPC MMA type descriptor from Str, advancing the pointer ov...
Definition: SemaPPC.cpp:281
@ AltiVecVector
is AltiVec vector