clang 19.0.0git
SemaStmtAsm.cpp
Go to the documentation of this file.
1//===--- SemaStmtAsm.cpp - Semantic Analysis for Asm Statements -----------===//
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 for inline asm statements.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/AST/ExprCXX.h"
16#include "clang/AST/TypeLoc.h"
20#include "clang/Sema/Lookup.h"
21#include "clang/Sema/Scope.h"
24#include "llvm/ADT/ArrayRef.h"
25#include "llvm/ADT/StringExtras.h"
26#include "llvm/ADT/StringSet.h"
27#include "llvm/MC/MCParser/MCAsmParser.h"
28#include <optional>
29using namespace clang;
30using namespace sema;
31
32/// Remove the upper-level LValueToRValue cast from an expression.
34 Expr *Parent = E;
35 Expr *ExprUnderCast = nullptr;
36 SmallVector<Expr *, 8> ParentsToUpdate;
37
38 while (true) {
39 ParentsToUpdate.push_back(Parent);
40 if (auto *ParenE = dyn_cast<ParenExpr>(Parent)) {
41 Parent = ParenE->getSubExpr();
42 continue;
43 }
44
45 Expr *Child = nullptr;
46 CastExpr *ParentCast = dyn_cast<CastExpr>(Parent);
47 if (ParentCast)
48 Child = ParentCast->getSubExpr();
49 else
50 return;
51
52 if (auto *CastE = dyn_cast<CastExpr>(Child))
53 if (CastE->getCastKind() == CK_LValueToRValue) {
54 ExprUnderCast = CastE->getSubExpr();
55 // LValueToRValue cast inside GCCAsmStmt requires an explicit cast.
56 ParentCast->setSubExpr(ExprUnderCast);
57 break;
58 }
59 Parent = Child;
60 }
61
62 // Update parent expressions to have same ValueType as the underlying.
63 assert(ExprUnderCast &&
64 "Should be reachable only if LValueToRValue cast was found!");
65 auto ValueKind = ExprUnderCast->getValueKind();
66 for (Expr *E : ParentsToUpdate)
67 E->setValueKind(ValueKind);
68}
69
70/// Emit a warning about usage of "noop"-like casts for lvalues (GNU extension)
71/// and fix the argument with removing LValueToRValue cast from the expression.
72static void emitAndFixInvalidAsmCastLValue(const Expr *LVal, Expr *BadArgument,
73 Sema &S) {
74 if (!S.getLangOpts().HeinousExtensions) {
75 S.Diag(LVal->getBeginLoc(), diag::err_invalid_asm_cast_lvalue)
76 << BadArgument->getSourceRange();
77 } else {
78 S.Diag(LVal->getBeginLoc(), diag::warn_invalid_asm_cast_lvalue)
79 << BadArgument->getSourceRange();
80 }
81 removeLValueToRValueCast(BadArgument);
82}
83
84/// CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently
85/// ignore "noop" casts in places where an lvalue is required by an inline asm.
86/// We emulate this behavior when -fheinous-gnu-extensions is specified, but
87/// provide a strong guidance to not use it.
88///
89/// This method checks to see if the argument is an acceptable l-value and
90/// returns false if it is a case we can handle.
91static bool CheckAsmLValue(Expr *E, Sema &S) {
92 // Type dependent expressions will be checked during instantiation.
93 if (E->isTypeDependent())
94 return false;
95
96 if (E->isLValue())
97 return false; // Cool, this is an lvalue.
98
99 // Okay, this is not an lvalue, but perhaps it is the result of a cast that we
100 // are supposed to allow.
101 const Expr *E2 = E->IgnoreParenNoopCasts(S.Context);
102 if (E != E2 && E2->isLValue()) {
104 // Accept, even if we emitted an error diagnostic.
105 return false;
106 }
107
108 // None of the above, just randomly invalid non-lvalue.
109 return true;
110}
111
112/// isOperandMentioned - Return true if the specified operand # is mentioned
113/// anywhere in the decomposed asm string.
114static bool
115isOperandMentioned(unsigned OpNo,
117 for (unsigned p = 0, e = AsmStrPieces.size(); p != e; ++p) {
118 const GCCAsmStmt::AsmStringPiece &Piece = AsmStrPieces[p];
119 if (!Piece.isOperand())
120 continue;
121
122 // If this is a reference to the input and if the input was the smaller
123 // one, then we have to reject this asm.
124 if (Piece.getOperandNo() == OpNo)
125 return true;
126 }
127 return false;
128}
129
130static bool CheckNakedParmReference(Expr *E, Sema &S) {
131 FunctionDecl *Func = dyn_cast<FunctionDecl>(S.CurContext);
132 if (!Func)
133 return false;
134 if (!Func->hasAttr<NakedAttr>())
135 return false;
136
137 SmallVector<Expr*, 4> WorkList;
138 WorkList.push_back(E);
139 while (WorkList.size()) {
140 Expr *E = WorkList.pop_back_val();
141 if (isa<CXXThisExpr>(E)) {
142 S.Diag(E->getBeginLoc(), diag::err_asm_naked_this_ref);
143 S.Diag(Func->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
144 return true;
145 }
146 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
147 if (isa<ParmVarDecl>(DRE->getDecl())) {
148 S.Diag(DRE->getBeginLoc(), diag::err_asm_naked_parm_ref);
149 S.Diag(Func->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
150 return true;
151 }
152 }
153 for (Stmt *Child : E->children()) {
154 if (Expr *E = dyn_cast_or_null<Expr>(Child))
155 WorkList.push_back(E);
156 }
157 }
158 return false;
159}
160
161/// Returns true if given expression is not compatible with inline
162/// assembly's memory constraint; false otherwise.
165 bool is_input_expr) {
166 enum {
167 ExprBitfield = 0,
168 ExprVectorElt,
169 ExprGlobalRegVar,
170 ExprSafeType
171 } EType = ExprSafeType;
172
173 // Bitfields, vector elements and global register variables are not
174 // compatible.
175 if (E->refersToBitField())
176 EType = ExprBitfield;
177 else if (E->refersToVectorElement())
178 EType = ExprVectorElt;
179 else if (E->refersToGlobalRegisterVar())
180 EType = ExprGlobalRegVar;
181
182 if (EType != ExprSafeType) {
183 S.Diag(E->getBeginLoc(), diag::err_asm_non_addr_value_in_memory_constraint)
184 << EType << is_input_expr << Info.getConstraintStr()
185 << E->getSourceRange();
186 return true;
187 }
188
189 return false;
190}
191
192// Extracting the register name from the Expression value,
193// if there is no register name to extract, returns ""
194static StringRef extractRegisterName(const Expr *Expression,
195 const TargetInfo &Target) {
196 Expression = Expression->IgnoreImpCasts();
197 if (const DeclRefExpr *AsmDeclRef = dyn_cast<DeclRefExpr>(Expression)) {
198 // Handle cases where the expression is a variable
199 const VarDecl *Variable = dyn_cast<VarDecl>(AsmDeclRef->getDecl());
200 if (Variable && Variable->getStorageClass() == SC_Register) {
201 if (AsmLabelAttr *Attr = Variable->getAttr<AsmLabelAttr>())
202 if (Target.isValidGCCRegisterName(Attr->getLabel()))
203 return Target.getNormalizedGCCRegisterName(Attr->getLabel(), true);
204 }
205 }
206 return "";
207}
208
209// Checks if there is a conflict between the input and output lists with the
210// clobbers list. If there's a conflict, returns the location of the
211// conflicted clobber, else returns nullptr
212static SourceLocation
214 StringLiteral **Clobbers, int NumClobbers,
215 unsigned NumLabels,
216 const TargetInfo &Target, ASTContext &Cont) {
217 llvm::StringSet<> InOutVars;
218 // Collect all the input and output registers from the extended asm
219 // statement in order to check for conflicts with the clobber list
220 for (unsigned int i = 0; i < Exprs.size() - NumLabels; ++i) {
221 StringRef Constraint = Constraints[i]->getString();
222 StringRef InOutReg = Target.getConstraintRegister(
223 Constraint, extractRegisterName(Exprs[i], Target));
224 if (InOutReg != "")
225 InOutVars.insert(InOutReg);
226 }
227 // Check for each item in the clobber list if it conflicts with the input
228 // or output
229 for (int i = 0; i < NumClobbers; ++i) {
230 StringRef Clobber = Clobbers[i]->getString();
231 // We only check registers, therefore we don't check cc and memory
232 // clobbers
233 if (Clobber == "cc" || Clobber == "memory" || Clobber == "unwind")
234 continue;
235 Clobber = Target.getNormalizedGCCRegisterName(Clobber, true);
236 // Go over the output's registers we collected
237 if (InOutVars.count(Clobber))
238 return Clobbers[i]->getBeginLoc();
239 }
240 return SourceLocation();
241}
242
244 bool IsVolatile, unsigned NumOutputs,
245 unsigned NumInputs, IdentifierInfo **Names,
246 MultiExprArg constraints, MultiExprArg Exprs,
247 Expr *asmString, MultiExprArg clobbers,
248 unsigned NumLabels,
249 SourceLocation RParenLoc) {
250 unsigned NumClobbers = clobbers.size();
251 StringLiteral **Constraints =
252 reinterpret_cast<StringLiteral**>(constraints.data());
253 StringLiteral *AsmString = cast<StringLiteral>(asmString);
254 StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.data());
255
256 SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
257
258 // The parser verifies that there is a string literal here.
259 assert(AsmString->isOrdinary());
260
261 FunctionDecl *FD = dyn_cast<FunctionDecl>(getCurLexicalContext());
262 llvm::StringMap<bool> FeatureMap;
263 Context.getFunctionFeatureMap(FeatureMap, FD);
264
265 for (unsigned i = 0; i != NumOutputs; i++) {
266 StringLiteral *Literal = Constraints[i];
267 assert(Literal->isOrdinary());
268
269 StringRef OutputName;
270 if (Names[i])
271 OutputName = Names[i]->getName();
272
273 TargetInfo::ConstraintInfo Info(Literal->getString(), OutputName);
275 !(LangOpts.HIPStdPar && LangOpts.CUDAIsDevice)) {
276 targetDiag(Literal->getBeginLoc(),
277 diag::err_asm_invalid_output_constraint)
278 << Info.getConstraintStr();
279 return new (Context)
280 GCCAsmStmt(Context, AsmLoc, IsSimple, IsVolatile, NumOutputs,
281 NumInputs, Names, Constraints, Exprs.data(), AsmString,
282 NumClobbers, Clobbers, NumLabels, RParenLoc);
283 }
284
285 ExprResult ER = CheckPlaceholderExpr(Exprs[i]);
286 if (ER.isInvalid())
287 return StmtError();
288 Exprs[i] = ER.get();
289
290 // Check that the output exprs are valid lvalues.
291 Expr *OutputExpr = Exprs[i];
292
293 // Referring to parameters is not allowed in naked functions.
294 if (CheckNakedParmReference(OutputExpr, *this))
295 return StmtError();
296
297 // Check that the output expression is compatible with memory constraint.
298 if (Info.allowsMemory() &&
299 checkExprMemoryConstraintCompat(*this, OutputExpr, Info, false))
300 return StmtError();
301
302 // Disallow bit-precise integer types, since the backends tend to have
303 // difficulties with abnormal sizes.
304 if (OutputExpr->getType()->isBitIntType())
305 return StmtError(
306 Diag(OutputExpr->getBeginLoc(), diag::err_asm_invalid_type)
307 << OutputExpr->getType() << 0 /*Input*/
308 << OutputExpr->getSourceRange());
309
310 OutputConstraintInfos.push_back(Info);
311
312 // If this is dependent, just continue.
313 if (OutputExpr->isTypeDependent())
314 continue;
315
317 OutputExpr->isModifiableLvalue(Context, /*Loc=*/nullptr);
318 switch (IsLV) {
319 case Expr::MLV_Valid:
320 // Cool, this is an lvalue.
321 break;
323 // This is OK too.
324 break;
326 const Expr *LVal = OutputExpr->IgnoreParenNoopCasts(Context);
327 emitAndFixInvalidAsmCastLValue(LVal, OutputExpr, *this);
328 // Accept, even if we emitted an error diagnostic.
329 break;
330 }
333 if (RequireCompleteType(OutputExpr->getBeginLoc(), Exprs[i]->getType(),
334 diag::err_dereference_incomplete_type))
335 return StmtError();
336 [[fallthrough]];
337 default:
338 return StmtError(Diag(OutputExpr->getBeginLoc(),
339 diag::err_asm_invalid_lvalue_in_output)
340 << OutputExpr->getSourceRange());
341 }
342
343 unsigned Size = Context.getTypeSize(OutputExpr->getType());
345 FeatureMap, Literal->getString(), Size)) {
346 targetDiag(OutputExpr->getBeginLoc(), diag::err_asm_invalid_output_size)
347 << Info.getConstraintStr();
348 return new (Context)
349 GCCAsmStmt(Context, AsmLoc, IsSimple, IsVolatile, NumOutputs,
350 NumInputs, Names, Constraints, Exprs.data(), AsmString,
351 NumClobbers, Clobbers, NumLabels, RParenLoc);
352 }
353 }
354
356
357 for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {
358 StringLiteral *Literal = Constraints[i];
359 assert(Literal->isOrdinary());
360
361 StringRef InputName;
362 if (Names[i])
363 InputName = Names[i]->getName();
364
365 TargetInfo::ConstraintInfo Info(Literal->getString(), InputName);
366 if (!Context.getTargetInfo().validateInputConstraint(OutputConstraintInfos,
367 Info)) {
368 targetDiag(Literal->getBeginLoc(), diag::err_asm_invalid_input_constraint)
369 << Info.getConstraintStr();
370 return new (Context)
371 GCCAsmStmt(Context, AsmLoc, IsSimple, IsVolatile, NumOutputs,
372 NumInputs, Names, Constraints, Exprs.data(), AsmString,
373 NumClobbers, Clobbers, NumLabels, RParenLoc);
374 }
375
376 ExprResult ER = CheckPlaceholderExpr(Exprs[i]);
377 if (ER.isInvalid())
378 return StmtError();
379 Exprs[i] = ER.get();
380
381 Expr *InputExpr = Exprs[i];
382
383 if (InputExpr->getType()->isMemberPointerType())
384 return StmtError(Diag(InputExpr->getBeginLoc(),
385 diag::err_asm_pmf_through_constraint_not_permitted)
386 << InputExpr->getSourceRange());
387
388 // Referring to parameters is not allowed in naked functions.
389 if (CheckNakedParmReference(InputExpr, *this))
390 return StmtError();
391
392 // Check that the input expression is compatible with memory constraint.
393 if (Info.allowsMemory() &&
394 checkExprMemoryConstraintCompat(*this, InputExpr, Info, true))
395 return StmtError();
396
397 // Only allow void types for memory constraints.
398 if (Info.allowsMemory() && !Info.allowsRegister()) {
399 if (CheckAsmLValue(InputExpr, *this))
400 return StmtError(Diag(InputExpr->getBeginLoc(),
401 diag::err_asm_invalid_lvalue_in_input)
402 << Info.getConstraintStr()
403 << InputExpr->getSourceRange());
404 } else {
406 if (Result.isInvalid())
407 return StmtError();
408
409 InputExpr = Exprs[i] = Result.get();
410
411 if (Info.requiresImmediateConstant() && !Info.allowsRegister()) {
412 if (!InputExpr->isValueDependent()) {
413 Expr::EvalResult EVResult;
414 if (InputExpr->EvaluateAsRValue(EVResult, Context, true)) {
415 // For compatibility with GCC, we also allow pointers that would be
416 // integral constant expressions if they were cast to int.
417 llvm::APSInt IntResult;
418 if (EVResult.Val.toIntegralConstant(IntResult, InputExpr->getType(),
419 Context))
420 if (!Info.isValidAsmImmediate(IntResult))
421 return StmtError(
422 Diag(InputExpr->getBeginLoc(),
423 diag::err_invalid_asm_value_for_constraint)
424 << toString(IntResult, 10) << Info.getConstraintStr()
425 << InputExpr->getSourceRange());
426 }
427 }
428 }
429 }
430
431 if (Info.allowsRegister()) {
432 if (InputExpr->getType()->isVoidType()) {
433 return StmtError(
434 Diag(InputExpr->getBeginLoc(), diag::err_asm_invalid_type_in_input)
435 << InputExpr->getType() << Info.getConstraintStr()
436 << InputExpr->getSourceRange());
437 }
438 }
439
440 if (InputExpr->getType()->isBitIntType())
441 return StmtError(
442 Diag(InputExpr->getBeginLoc(), diag::err_asm_invalid_type)
443 << InputExpr->getType() << 1 /*Output*/
444 << InputExpr->getSourceRange());
445
446 InputConstraintInfos.push_back(Info);
447
448 const Type *Ty = Exprs[i]->getType().getTypePtr();
449 if (Ty->isDependentType())
450 continue;
451
452 if (!Ty->isVoidType() || !Info.allowsMemory())
453 if (RequireCompleteType(InputExpr->getBeginLoc(), Exprs[i]->getType(),
454 diag::err_dereference_incomplete_type))
455 return StmtError();
456
457 unsigned Size = Context.getTypeSize(Ty);
458 if (!Context.getTargetInfo().validateInputSize(FeatureMap,
459 Literal->getString(), Size))
460 return targetDiag(InputExpr->getBeginLoc(),
461 diag::err_asm_invalid_input_size)
462 << Info.getConstraintStr();
463 }
464
465 std::optional<SourceLocation> UnwindClobberLoc;
466
467 // Check that the clobbers are valid.
468 for (unsigned i = 0; i != NumClobbers; i++) {
469 StringLiteral *Literal = Clobbers[i];
470 assert(Literal->isOrdinary());
471
472 StringRef Clobber = Literal->getString();
473
474 if (!Context.getTargetInfo().isValidClobber(Clobber)) {
475 targetDiag(Literal->getBeginLoc(), diag::err_asm_unknown_register_name)
476 << Clobber;
477 return new (Context)
478 GCCAsmStmt(Context, AsmLoc, IsSimple, IsVolatile, NumOutputs,
479 NumInputs, Names, Constraints, Exprs.data(), AsmString,
480 NumClobbers, Clobbers, NumLabels, RParenLoc);
481 }
482
483 if (Clobber == "unwind") {
484 UnwindClobberLoc = Literal->getBeginLoc();
485 }
486 }
487
488 // Using unwind clobber and asm-goto together is not supported right now.
489 if (UnwindClobberLoc && NumLabels > 0) {
490 targetDiag(*UnwindClobberLoc, diag::err_asm_unwind_and_goto);
491 return new (Context)
492 GCCAsmStmt(Context, AsmLoc, IsSimple, IsVolatile, NumOutputs, NumInputs,
493 Names, Constraints, Exprs.data(), AsmString, NumClobbers,
494 Clobbers, NumLabels, RParenLoc);
495 }
496
497 GCCAsmStmt *NS =
498 new (Context) GCCAsmStmt(Context, AsmLoc, IsSimple, IsVolatile, NumOutputs,
499 NumInputs, Names, Constraints, Exprs.data(),
500 AsmString, NumClobbers, Clobbers, NumLabels,
501 RParenLoc);
502 // Validate the asm string, ensuring it makes sense given the operands we
503 // have.
505 unsigned DiagOffs;
506 if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) {
507 targetDiag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID)
508 << AsmString->getSourceRange();
509 return NS;
510 }
511
512 // Validate constraints and modifiers.
513 for (unsigned i = 0, e = Pieces.size(); i != e; ++i) {
514 GCCAsmStmt::AsmStringPiece &Piece = Pieces[i];
515 if (!Piece.isOperand()) continue;
516
517 // Look for the correct constraint index.
518 unsigned ConstraintIdx = Piece.getOperandNo();
519 unsigned NumOperands = NS->getNumOutputs() + NS->getNumInputs();
520 // Labels are the last in the Exprs list.
521 if (NS->isAsmGoto() && ConstraintIdx >= NumOperands)
522 continue;
523 // Look for the (ConstraintIdx - NumOperands + 1)th constraint with
524 // modifier '+'.
525 if (ConstraintIdx >= NumOperands) {
526 unsigned I = 0, E = NS->getNumOutputs();
527
528 for (unsigned Cnt = ConstraintIdx - NumOperands; I != E; ++I)
529 if (OutputConstraintInfos[I].isReadWrite() && Cnt-- == 0) {
530 ConstraintIdx = I;
531 break;
532 }
533
534 assert(I != E && "Invalid operand number should have been caught in "
535 " AnalyzeAsmString");
536 }
537
538 // Now that we have the right indexes go ahead and check.
539 StringLiteral *Literal = Constraints[ConstraintIdx];
540 const Type *Ty = Exprs[ConstraintIdx]->getType().getTypePtr();
541 if (Ty->isDependentType() || Ty->isIncompleteType())
542 continue;
543
544 unsigned Size = Context.getTypeSize(Ty);
545 std::string SuggestedModifier;
547 Literal->getString(), Piece.getModifier(), Size,
548 SuggestedModifier)) {
549 targetDiag(Exprs[ConstraintIdx]->getBeginLoc(),
550 diag::warn_asm_mismatched_size_modifier);
551
552 if (!SuggestedModifier.empty()) {
553 auto B = targetDiag(Piece.getRange().getBegin(),
554 diag::note_asm_missing_constraint_modifier)
555 << SuggestedModifier;
556 SuggestedModifier = "%" + SuggestedModifier + Piece.getString();
557 B << FixItHint::CreateReplacement(Piece.getRange(), SuggestedModifier);
558 }
559 }
560 }
561
562 // Validate tied input operands for type mismatches.
563 unsigned NumAlternatives = ~0U;
564 for (unsigned i = 0, e = OutputConstraintInfos.size(); i != e; ++i) {
565 TargetInfo::ConstraintInfo &Info = OutputConstraintInfos[i];
566 StringRef ConstraintStr = Info.getConstraintStr();
567 unsigned AltCount = ConstraintStr.count(',') + 1;
568 if (NumAlternatives == ~0U) {
569 NumAlternatives = AltCount;
570 } else if (NumAlternatives != AltCount) {
571 targetDiag(NS->getOutputExpr(i)->getBeginLoc(),
572 diag::err_asm_unexpected_constraint_alternatives)
573 << NumAlternatives << AltCount;
574 return NS;
575 }
576 }
577 SmallVector<size_t, 4> InputMatchedToOutput(OutputConstraintInfos.size(),
578 ~0U);
579 for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) {
580 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
581 StringRef ConstraintStr = Info.getConstraintStr();
582 unsigned AltCount = ConstraintStr.count(',') + 1;
583 if (NumAlternatives == ~0U) {
584 NumAlternatives = AltCount;
585 } else if (NumAlternatives != AltCount) {
586 targetDiag(NS->getInputExpr(i)->getBeginLoc(),
587 diag::err_asm_unexpected_constraint_alternatives)
588 << NumAlternatives << AltCount;
589 return NS;
590 }
591
592 // If this is a tied constraint, verify that the output and input have
593 // either exactly the same type, or that they are int/ptr operands with the
594 // same size (int/long, int*/long, are ok etc).
595 if (!Info.hasTiedOperand()) continue;
596
597 unsigned TiedTo = Info.getTiedOperand();
598 unsigned InputOpNo = i+NumOutputs;
599 Expr *OutputExpr = Exprs[TiedTo];
600 Expr *InputExpr = Exprs[InputOpNo];
601
602 // Make sure no more than one input constraint matches each output.
603 assert(TiedTo < InputMatchedToOutput.size() && "TiedTo value out of range");
604 if (InputMatchedToOutput[TiedTo] != ~0U) {
605 targetDiag(NS->getInputExpr(i)->getBeginLoc(),
606 diag::err_asm_input_duplicate_match)
607 << TiedTo;
608 targetDiag(NS->getInputExpr(InputMatchedToOutput[TiedTo])->getBeginLoc(),
609 diag::note_asm_input_duplicate_first)
610 << TiedTo;
611 return NS;
612 }
613 InputMatchedToOutput[TiedTo] = i;
614
615 if (OutputExpr->isTypeDependent() || InputExpr->isTypeDependent())
616 continue;
617
618 QualType InTy = InputExpr->getType();
619 QualType OutTy = OutputExpr->getType();
620 if (Context.hasSameType(InTy, OutTy))
621 continue; // All types can be tied to themselves.
622
623 // Decide if the input and output are in the same domain (integer/ptr or
624 // floating point.
625 enum AsmDomain {
626 AD_Int, AD_FP, AD_Other
627 } InputDomain, OutputDomain;
628
629 if (InTy->isIntegerType() || InTy->isPointerType())
630 InputDomain = AD_Int;
631 else if (InTy->isRealFloatingType())
632 InputDomain = AD_FP;
633 else
634 InputDomain = AD_Other;
635
636 if (OutTy->isIntegerType() || OutTy->isPointerType())
637 OutputDomain = AD_Int;
638 else if (OutTy->isRealFloatingType())
639 OutputDomain = AD_FP;
640 else
641 OutputDomain = AD_Other;
642
643 // They are ok if they are the same size and in the same domain. This
644 // allows tying things like:
645 // void* to int*
646 // void* to int if they are the same size.
647 // double to long double if they are the same size.
648 //
649 uint64_t OutSize = Context.getTypeSize(OutTy);
650 uint64_t InSize = Context.getTypeSize(InTy);
651 if (OutSize == InSize && InputDomain == OutputDomain &&
652 InputDomain != AD_Other)
653 continue;
654
655 // If the smaller input/output operand is not mentioned in the asm string,
656 // then we can promote the smaller one to a larger input and the asm string
657 // won't notice.
658 bool SmallerValueMentioned = false;
659
660 // If this is a reference to the input and if the input was the smaller
661 // one, then we have to reject this asm.
662 if (isOperandMentioned(InputOpNo, Pieces)) {
663 // This is a use in the asm string of the smaller operand. Since we
664 // codegen this by promoting to a wider value, the asm will get printed
665 // "wrong".
666 SmallerValueMentioned |= InSize < OutSize;
667 }
668 if (isOperandMentioned(TiedTo, Pieces)) {
669 // If this is a reference to the output, and if the output is the larger
670 // value, then it's ok because we'll promote the input to the larger type.
671 SmallerValueMentioned |= OutSize < InSize;
672 }
673
674 // If the smaller value wasn't mentioned in the asm string, and if the
675 // output was a register, just extend the shorter one to the size of the
676 // larger one.
677 if (!SmallerValueMentioned && InputDomain != AD_Other &&
678 OutputConstraintInfos[TiedTo].allowsRegister()) {
679 // FIXME: GCC supports the OutSize to be 128 at maximum. Currently codegen
680 // crash when the size larger than the register size. So we limit it here.
681 if (OutTy->isStructureType() &&
682 Context.getIntTypeForBitwidth(OutSize, /*Signed*/ false).isNull()) {
683 targetDiag(OutputExpr->getExprLoc(), diag::err_store_value_to_reg);
684 return NS;
685 }
686
687 continue;
688 }
689
690 // Either both of the operands were mentioned or the smaller one was
691 // mentioned. One more special case that we'll allow: if the tied input is
692 // integer, unmentioned, and is a constant, then we'll allow truncating it
693 // down to the size of the destination.
694 if (InputDomain == AD_Int && OutputDomain == AD_Int &&
695 !isOperandMentioned(InputOpNo, Pieces) &&
696 InputExpr->isEvaluatable(Context)) {
697 CastKind castKind =
698 (OutTy->isBooleanType() ? CK_IntegralToBoolean : CK_IntegralCast);
699 InputExpr = ImpCastExprToType(InputExpr, OutTy, castKind).get();
700 Exprs[InputOpNo] = InputExpr;
701 NS->setInputExpr(i, InputExpr);
702 continue;
703 }
704
705 targetDiag(InputExpr->getBeginLoc(), diag::err_asm_tying_incompatible_types)
706 << InTy << OutTy << OutputExpr->getSourceRange()
707 << InputExpr->getSourceRange();
708 return NS;
709 }
710
711 // Check for conflicts between clobber list and input or output lists
712 SourceLocation ConstraintLoc =
713 getClobberConflictLocation(Exprs, Constraints, Clobbers, NumClobbers,
714 NumLabels,
716 if (ConstraintLoc.isValid())
717 targetDiag(ConstraintLoc, diag::error_inoutput_conflict_with_clobber);
718
719 // Check for duplicate asm operand name between input, output and label lists.
720 typedef std::pair<StringRef , Expr *> NamedOperand;
721 SmallVector<NamedOperand, 4> NamedOperandList;
722 for (unsigned i = 0, e = NumOutputs + NumInputs + NumLabels; i != e; ++i)
723 if (Names[i])
724 NamedOperandList.emplace_back(
725 std::make_pair(Names[i]->getName(), Exprs[i]));
726 // Sort NamedOperandList.
727 llvm::stable_sort(NamedOperandList, llvm::less_first());
728 // Find adjacent duplicate operand.
730 std::adjacent_find(begin(NamedOperandList), end(NamedOperandList),
731 [](const NamedOperand &LHS, const NamedOperand &RHS) {
732 return LHS.first == RHS.first;
733 });
734 if (Found != NamedOperandList.end()) {
735 Diag((Found + 1)->second->getBeginLoc(),
736 diag::error_duplicate_asm_operand_name)
737 << (Found + 1)->first;
738 Diag(Found->second->getBeginLoc(), diag::note_duplicate_asm_operand_name)
739 << Found->first;
740 return StmtError();
741 }
742 if (NS->isAsmGoto())
744
747 return NS;
748}
749
751 llvm::InlineAsmIdentifierInfo &Info) {
752 QualType T = Res->getType();
753 Expr::EvalResult Eval;
754 if (T->isFunctionType() || T->isDependentType())
755 return Info.setLabel(Res);
756 if (Res->isPRValue()) {
757 bool IsEnum = isa<clang::EnumType>(T);
758 if (DeclRefExpr *DRE = dyn_cast<clang::DeclRefExpr>(Res))
759 if (DRE->getDecl()->getKind() == Decl::EnumConstant)
760 IsEnum = true;
761 if (IsEnum && Res->EvaluateAsRValue(Eval, Context))
762 return Info.setEnum(Eval.Val.getInt().getSExtValue());
763
764 return Info.setLabel(Res);
765 }
766 unsigned Size = Context.getTypeSizeInChars(T).getQuantity();
767 unsigned Type = Size;
768 if (const auto *ATy = Context.getAsArrayType(T))
769 Type = Context.getTypeSizeInChars(ATy->getElementType()).getQuantity();
770 bool IsGlobalLV = false;
771 if (Res->EvaluateAsLValue(Eval, Context))
772 IsGlobalLV = Eval.isGlobalLValue();
773 Info.setVar(Res, IsGlobalLV, Size, Type);
774}
775
777 SourceLocation TemplateKWLoc,
779 bool IsUnevaluatedContext) {
780
781 if (IsUnevaluatedContext)
785
786 ExprResult Result = ActOnIdExpression(getCurScope(), SS, TemplateKWLoc, Id,
787 /*trailing lparen*/ false,
788 /*is & operand*/ false,
789 /*CorrectionCandidateCallback=*/nullptr,
790 /*IsInlineAsmIdentifier=*/ true);
791
792 if (IsUnevaluatedContext)
794
795 if (!Result.isUsable()) return Result;
796
798 if (!Result.isUsable()) return Result;
799
800 // Referring to parameters is not allowed in naked functions.
801 if (CheckNakedParmReference(Result.get(), *this))
802 return ExprError();
803
804 QualType T = Result.get()->getType();
805
806 if (T->isDependentType()) {
807 return Result;
808 }
809
810 // Any sort of function type is fine.
811 if (T->isFunctionType()) {
812 return Result;
813 }
814
815 // Otherwise, it needs to be a complete type.
816 if (RequireCompleteExprType(Result.get(), diag::err_asm_incomplete_type)) {
817 return ExprError();
818 }
819
820 return Result;
821}
822
823bool Sema::LookupInlineAsmField(StringRef Base, StringRef Member,
824 unsigned &Offset, SourceLocation AsmLoc) {
825 Offset = 0;
827 Member.split(Members, ".");
828
829 NamedDecl *FoundDecl = nullptr;
830
831 // MS InlineAsm uses 'this' as a base
832 if (getLangOpts().CPlusPlus && Base.equals("this")) {
833 if (const Type *PT = getCurrentThisType().getTypePtrOrNull())
834 FoundDecl = PT->getPointeeType()->getAsTagDecl();
835 } else {
838 if (LookupName(BaseResult, getCurScope()) && BaseResult.isSingleResult())
839 FoundDecl = BaseResult.getFoundDecl();
840 }
841
842 if (!FoundDecl)
843 return true;
844
845 for (StringRef NextMember : Members) {
846 const RecordType *RT = nullptr;
847 if (VarDecl *VD = dyn_cast<VarDecl>(FoundDecl))
848 RT = VD->getType()->getAs<RecordType>();
849 else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(FoundDecl)) {
850 MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
851 // MS InlineAsm often uses struct pointer aliases as a base
852 QualType QT = TD->getUnderlyingType();
853 if (const auto *PT = QT->getAs<PointerType>())
854 QT = PT->getPointeeType();
855 RT = QT->getAs<RecordType>();
856 } else if (TypeDecl *TD = dyn_cast<TypeDecl>(FoundDecl))
857 RT = TD->getTypeForDecl()->getAs<RecordType>();
858 else if (FieldDecl *TD = dyn_cast<FieldDecl>(FoundDecl))
859 RT = TD->getType()->getAs<RecordType>();
860 if (!RT)
861 return true;
862
863 if (RequireCompleteType(AsmLoc, QualType(RT, 0),
864 diag::err_asm_incomplete_type))
865 return true;
866
867 LookupResult FieldResult(*this, &Context.Idents.get(NextMember),
869
870 if (!LookupQualifiedName(FieldResult, RT->getDecl()))
871 return true;
872
873 if (!FieldResult.isSingleResult())
874 return true;
875 FoundDecl = FieldResult.getFoundDecl();
876
877 // FIXME: Handle IndirectFieldDecl?
878 FieldDecl *FD = dyn_cast<FieldDecl>(FoundDecl);
879 if (!FD)
880 return true;
881
883 unsigned i = FD->getFieldIndex();
885 Offset += (unsigned)Result.getQuantity();
886 }
887
888 return false;
889}
890
893 SourceLocation AsmLoc) {
894
895 QualType T = E->getType();
896 if (T->isDependentType()) {
897 DeclarationNameInfo NameInfo;
898 NameInfo.setLoc(AsmLoc);
899 NameInfo.setName(&Context.Idents.get(Member));
901 Context, E, T, /*IsArrow=*/false, AsmLoc, NestedNameSpecifierLoc(),
903 /*FirstQualifierFoundInScope=*/nullptr, NameInfo, /*TemplateArgs=*/nullptr);
904 }
905
906 const RecordType *RT = T->getAs<RecordType>();
907 // FIXME: Diagnose this as field access into a scalar type.
908 if (!RT)
909 return ExprResult();
910
911 LookupResult FieldResult(*this, &Context.Idents.get(Member), AsmLoc,
913
914 if (!LookupQualifiedName(FieldResult, RT->getDecl()))
915 return ExprResult();
916
917 // Only normal and indirect field results will work.
918 ValueDecl *FD = dyn_cast<FieldDecl>(FieldResult.getFoundDecl());
919 if (!FD)
920 FD = dyn_cast<IndirectFieldDecl>(FieldResult.getFoundDecl());
921 if (!FD)
922 return ExprResult();
923
924 // Make an Expr to thread through OpDecl.
926 E, E->getType(), AsmLoc, /*IsArrow=*/false, CXXScopeSpec(),
927 SourceLocation(), nullptr, FieldResult, nullptr, nullptr);
928
929 return Result;
930}
931
933 ArrayRef<Token> AsmToks,
934 StringRef AsmString,
935 unsigned NumOutputs, unsigned NumInputs,
936 ArrayRef<StringRef> Constraints,
937 ArrayRef<StringRef> Clobbers,
938 ArrayRef<Expr*> Exprs,
939 SourceLocation EndLoc) {
940 bool IsSimple = (NumOutputs != 0 || NumInputs != 0);
942
943 bool InvalidOperand = false;
944 for (uint64_t I = 0; I < NumOutputs + NumInputs; ++I) {
945 Expr *E = Exprs[I];
946 if (E->getType()->isBitIntType()) {
947 InvalidOperand = true;
948 Diag(E->getBeginLoc(), diag::err_asm_invalid_type)
949 << E->getType() << (I < NumOutputs)
950 << E->getSourceRange();
951 } else if (E->refersToBitField()) {
952 InvalidOperand = true;
953 FieldDecl *BitField = E->getSourceBitField();
954 Diag(E->getBeginLoc(), diag::err_ms_asm_bitfield_unsupported)
955 << E->getSourceRange();
956 Diag(BitField->getLocation(), diag::note_bitfield_decl);
957 }
958 }
959 if (InvalidOperand)
960 return StmtError();
961
962 MSAsmStmt *NS =
963 new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc, IsSimple,
964 /*IsVolatile*/ true, AsmToks, NumOutputs, NumInputs,
965 Constraints, Exprs, AsmString,
966 Clobbers, EndLoc);
967 return NS;
968}
969
970LabelDecl *Sema::GetOrCreateMSAsmLabel(StringRef ExternalLabelName,
971 SourceLocation Location,
972 bool AlwaysCreate) {
974 Location);
975
976 if (Label->isMSAsmLabel()) {
977 // If we have previously created this label implicitly, mark it as used.
978 Label->markUsed(Context);
979 } else {
980 // Otherwise, insert it, but only resolve it if we have seen the label itself.
981 std::string InternalName;
982 llvm::raw_string_ostream OS(InternalName);
983 // Create an internal name for the label. The name should not be a valid
984 // mangled name, and should be unique. We use a dot to make the name an
985 // invalid mangled name. We use LLVM's inline asm ${:uid} escape so that a
986 // unique label is generated each time this blob is emitted, even after
987 // inlining or LTO.
988 OS << "__MSASMLABEL_.${:uid}__";
989 for (char C : ExternalLabelName) {
990 OS << C;
991 // We escape '$' in asm strings by replacing it with "$$"
992 if (C == '$')
993 OS << '$';
994 }
995 Label->setMSAsmLabel(OS.str());
996 }
997 if (AlwaysCreate) {
998 // The label might have been created implicitly from a previously encountered
999 // goto statement. So, for both newly created and looked up labels, we mark
1000 // them as resolved.
1001 Label->setMSAsmLabelResolved();
1002 }
1003 // Adjust their location for being able to generate accurate diagnostics.
1004 Label->setLocation(Location);
1005
1006 return Label;
1007}
NodeId Parent
Definition: ASTDiff.cpp:191
int Id
Definition: ASTDiff.cpp:190
Defines the clang::Expr interface and subclasses for C++ expressions.
llvm::MachO::Target Target
Definition: MachO.h:48
Defines the clang::Preprocessor interface.
static std::string getName(const CallEvent &Call)
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
static SourceLocation getClobberConflictLocation(MultiExprArg Exprs, StringLiteral **Constraints, StringLiteral **Clobbers, int NumClobbers, unsigned NumLabels, const TargetInfo &Target, ASTContext &Cont)
static bool isOperandMentioned(unsigned OpNo, ArrayRef< GCCAsmStmt::AsmStringPiece > AsmStrPieces)
isOperandMentioned - Return true if the specified operand # is mentioned anywhere in the decomposed a...
static bool CheckAsmLValue(Expr *E, Sema &S)
CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently ignore "noop" casts in p...
Definition: SemaStmtAsm.cpp:91
static StringRef extractRegisterName(const Expr *Expression, const TargetInfo &Target)
static bool CheckNakedParmReference(Expr *E, Sema &S)
static bool checkExprMemoryConstraintCompat(Sema &S, Expr *E, TargetInfo::ConstraintInfo &Info, bool is_input_expr)
Returns true if given expression is not compatible with inline assembly's memory constraint; false ot...
static void removeLValueToRValueCast(Expr *E)
Remove the upper-level LValueToRValue cast from an expression.
Definition: SemaStmtAsm.cpp:33
static void emitAndFixInvalidAsmCastLValue(const Expr *LVal, Expr *BadArgument, Sema &S)
Emit a warning about usage of "noop"-like casts for lvalues (GNU extension) and fix the argument with...
Definition: SemaStmtAsm.cpp:72
Defines the clang::TypeLoc interface and its subclasses.
std::string Label
APSInt & getInt()
Definition: APValue.h:423
bool toIntegralConstant(APSInt &Result, QualType SrcTy, const ASTContext &Ctx) const
Try to convert this value to an integral constant.
Definition: APValue.cpp:954
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2579
IdentifierTable & Idents
Definition: ASTContext.h:644
QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const
getIntTypeForBitwidth - sets integer QualTy according to specified details: bitwidth,...
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2329
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:757
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) const
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:38
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:200
PtrTy get() const
Definition: Ownership.h:170
bool isInvalid() const
Definition: Ownership.h:166
Attr - This represents one attribute.
Definition: Attr.h:42
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: ExprCXX.cpp:1484
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:73
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3483
void setSubExpr(Expr *E)
Definition: Expr.h:3535
Expr * getSubExpr()
Definition: Expr.h:3533
SourceLocation getBegin() const
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
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1260
SourceLocation getLocation() const
Definition: DeclBase.h:446
This represents one expression.
Definition: Expr.h:110
Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY
Skip past any parentheses and casts which do not change the value (including ptr->int casts of the sa...
Definition: Expr.cpp:3086
isModifiableLvalueResult isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, does not have an incomplet...
bool isValueDependent() const
Determines whether the value of this expression depends on.
Definition: Expr.h:175
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:437
bool refersToVectorElement() const
Returns whether this expression refers to a vector element.
Definition: Expr.cpp:4133
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Definition: Expr.h:192
bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsLValue - Evaluate an expression to see if we can fold it to an lvalue with link time known ...
bool isEvaluatable(const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
isEvaluatable - Call EvaluateAsRValue to see if this expression can be constant folded without side-e...
bool isPRValue() const
Definition: Expr.h:278
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
Definition: Expr.h:277
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
Definition: Expr.cpp:4079
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
Definition: Expr.h:454
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:277
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
Definition: Expr.h:469
isModifiableLvalueResult
Definition: Expr.h:297
@ MLV_LValueCast
Definition: Expr.h:303
@ MLV_IncompleteType
Definition: Expr.h:304
@ MLV_Valid
Definition: Expr.h:298
@ MLV_ArrayType
Definition: Expr.h:308
@ MLV_IncompleteVoidType
Definition: Expr.h:300
QualType getType() const
Definition: Expr.h:142
bool refersToGlobalRegisterVar() const
Returns whether this expression refers to a global register variable.
Definition: Expr.cpp:4158
Represents a member of a struct/union/class.
Definition: Decl.h:3058
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
Definition: Decl.cpp:4646
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Definition: Diagnostic.h:134
Represents a function declaration or definition.
Definition: Decl.h:1971
AsmStringPiece - this is part of a decomposed asm string specification (for use with the AnalyzeAsmSt...
Definition: Stmt.h:3299
const std::string & getString() const
Definition: Stmt.h:3324
unsigned getOperandNo() const
Definition: Stmt.h:3326
CharSourceRange getRange() const
Definition: Stmt.h:3331
char getModifier() const
getModifier - Get the modifier for this operand, if present.
Definition: Stmt.cpp:500
This represents a GCC inline-assembly statement extension.
Definition: Stmt.h:3264
One of these records is kept for each identifier that is lexed.
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
Represents the declaration of a label.
Definition: Decl.h:499
Represents the results of name lookup.
Definition: Lookup.h:46
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Lookup.h:566
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Lookup.h:331
This represents a Microsoft inline-assembly statement extension.
Definition: Stmt.h:3487
This represents a decl that may have a name.
Definition: Decl.h:249
A C++ nested-name-specifier augmented with source location information.
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2929
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
A (possibly-)qualified type.
Definition: Type.h:738
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:805
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:5339
RecordDecl * getDecl() const
Definition: Type.h:5349
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
Definition: SemaBase.cpp:56
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:457
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
Scope * getCurScope() const
Retrieve the parser's current scope.
Definition: Sema.h:698
ExprResult BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, ActOnMemberAccessExtraArgs *ExtraArgs=nullptr)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
Definition: Sema.h:7368
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:7376
StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc, ArrayRef< Token > AsmToks, StringRef AsmString, unsigned NumOutputs, unsigned NumInputs, ArrayRef< StringRef > Constraints, ArrayRef< StringRef > Clobbers, ArrayRef< Expr * > Exprs, SourceLocation EndLoc)
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
Definition: SemaExpr.cpp:17683
ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, CorrectionCandidateCallback *CCC=nullptr, bool IsInlineAsmIdentifier=false, Token *KeywordReplacement=nullptr)
Definition: SemaExpr.cpp:2692
void setFunctionHasBranchIntoScope()
Definition: Sema.cpp:2296
ExprResult LookupInlineAsmIdentifier(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool IsUnevaluatedContext)
ASTContext & Context
Definition: Sema.h:858
void CleanupVarDeclMarking()
Definition: SemaExpr.cpp:19913
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
Definition: SemaExpr.cpp:762
void PopExpressionEvaluationContext()
Definition: SemaExpr.cpp:18109
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
Definition: Sema.cpp:645
const LangOptions & getLangOpts() const
Definition: Sema.h:520
bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type of the given expression is complete.
Definition: SemaType.cpp:9246
@ ReuseLambdaContextDecl
Definition: Sema.h:5232
Preprocessor & PP
Definition: Sema.h:857
const LangOptions & LangOpts
Definition: Sema.h:856
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
Definition: SemaExpr.cpp:20321
DeclContext * getCurLexicalContext() const
Definition: Sema.h:702
SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL, unsigned ByteNo) const
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:996
void FillInlineAsmIdentifierInfo(Expr *Res, llvm::InlineAsmIdentifierInfo &Info)
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
Definition: SemaExpr.cpp:21237
bool LookupInlineAsmField(StringRef Base, StringRef Member, unsigned &Offset, SourceLocation AsmLoc)
LabelDecl * LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc, SourceLocation GnuLabelLoc=SourceLocation())
LookupOrCreateLabel - Do a name lookup of a label with the specified name.
ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member, SourceLocation AsmLoc)
void setFunctionHasBranchProtectedScope()
Definition: Sema.cpp:2301
@ UnevaluatedAbstract
The current expression occurs within an unevaluated operand that unconditionally permits abstract ref...
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:9276
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void DiscardCleanupsInEvaluationContext()
Definition: SemaExpr.cpp:18187
LabelDecl * GetOrCreateMSAsmLabel(StringRef ExternalLabelName, SourceLocation Location, bool AlwaysCreate)
SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, const FunctionDecl *FD=nullptr)
Definition: Sema.cpp:1899
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, bool IsVolatile, unsigned NumOutputs, unsigned NumInputs, IdentifierInfo **Names, MultiExprArg Constraints, MultiExprArg Exprs, Expr *AsmString, MultiExprArg Clobbers, unsigned NumLabels, SourceLocation RParenLoc)
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
Stmt - This represents one statement.
Definition: Stmt.h:84
child_range children()
Definition: Stmt.cpp:287
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:326
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:338
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1773
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.h:1954
StringRef getString() const
Definition: Expr.h:1850
bool isOrdinary() const
Definition: Expr.h:1897
Exposes information about the current target.
Definition: TargetInfo.h:213
bool validateInputConstraint(MutableArrayRef< ConstraintInfo > OutputConstraints, ConstraintInfo &info) const
Definition: TargetInfo.cpp:812
virtual bool validateOutputSize(const llvm::StringMap< bool > &FeatureMap, StringRef, unsigned) const
Definition: TargetInfo.h:1183
virtual bool validateInputSize(const llvm::StringMap< bool > &FeatureMap, StringRef, unsigned) const
Definition: TargetInfo.h:1189
virtual bool validateConstraintModifier(StringRef, char, unsigned, std::string &) const
Definition: TargetInfo.h:1195
bool validateOutputConstraint(ConstraintInfo &Info) const
Definition: TargetInfo.cpp:715
bool isValidClobber(StringRef Name) const
Returns whether the passed in string is a valid clobber in an inline asm statement.
Definition: TargetInfo.cpp:621
Represents a declaration of a type.
Definition: Decl.h:3391
The base class of the type hierarchy.
Definition: Type.h:1607
bool isStructureType() const
Definition: Type.cpp:628
bool isVoidType() const
Definition: Type.h:7695
bool isBooleanType() const
Definition: Type.h:7823
bool isPointerType() const
Definition: Type.h:7402
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:7735
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition: Type.cpp:694
bool isBitIntType() const
Definition: Type.h:7630
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2443
bool isMemberPointerType() const
Definition: Type.h:7450
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
Definition: Type.cpp:2350
bool isFunctionType() const
Definition: Type.h:7398
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:2254
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:7913
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3433
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:1024
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:706
Represents a variable declaration or definition.
Definition: Decl.h:918
Defines the clang::TargetInfo interface.
The JSON file list parser is used to communicate input to InstallAPI.
@ CPlusPlus
Definition: LangStandard.h:55
@ SC_Register
Definition: Specifiers.h:254
StmtResult StmtError()
Definition: Ownership.h:265
@ Result
The result type of a method or function.
ActionResult< Expr * > ExprResult
Definition: Ownership.h:248
ExprResult ExprError()
Definition: Ownership.h:264
CastKind
CastKind - The kind of operation required for a conversion.
const FunctionProtoType * T
ActionResult< CXXBaseSpecifier * > BaseResult
Definition: Ownership.h:251
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
void setLoc(SourceLocation L)
setLoc - Sets the main location of the declaration name.
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:642
APValue Val
Val - This is the value the expression can be folded to.
Definition: Expr.h:644
const std::string & getConstraintStr() const
Definition: TargetInfo.h:1095
bool isValidAsmImmediate(const llvm::APInt &Value) const
Definition: TargetInfo.h:1120
bool hasTiedOperand() const
Return true if this input operand is a matching constraint that ties it to an output operand.
Definition: TargetInfo.h:1111