clang  14.0.0git
ParseStmtAsm.cpp
Go to the documentation of this file.
1 //===---- ParseStmtAsm.cpp - Assembly Statement Parser --------------------===//
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 parsing for GCC and Microsoft inline assembly.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/AST/ASTContext.h"
14 #include "clang/Basic/Diagnostic.h"
15 #include "clang/Basic/TargetInfo.h"
16 #include "clang/Parse/Parser.h"
18 #include "llvm/ADT/SmallString.h"
19 #include "llvm/ADT/StringExtras.h"
20 #include "llvm/MC/MCAsmInfo.h"
21 #include "llvm/MC/MCContext.h"
22 #include "llvm/MC/MCInstPrinter.h"
23 #include "llvm/MC/MCInstrInfo.h"
24 #include "llvm/MC/MCObjectFileInfo.h"
25 #include "llvm/MC/MCParser/MCAsmParser.h"
26 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
27 #include "llvm/MC/MCRegisterInfo.h"
28 #include "llvm/MC/MCStreamer.h"
29 #include "llvm/MC/MCSubtargetInfo.h"
30 #include "llvm/MC/MCTargetOptions.h"
31 #include "llvm/MC/TargetRegistry.h"
32 #include "llvm/Support/SourceMgr.h"
33 #include "llvm/Support/TargetSelect.h"
34 using namespace clang;
35 
36 namespace {
37 class ClangAsmParserCallback : public llvm::MCAsmParserSemaCallback {
38  Parser &TheParser;
39  SourceLocation AsmLoc;
40  StringRef AsmString;
41 
42  /// The tokens we streamed into AsmString and handed off to MC.
43  ArrayRef<Token> AsmToks;
44 
45  /// The offset of each token in AsmToks within AsmString.
46  ArrayRef<unsigned> AsmTokOffsets;
47 
48 public:
49  ClangAsmParserCallback(Parser &P, SourceLocation Loc, StringRef AsmString,
50  ArrayRef<Token> Toks, ArrayRef<unsigned> Offsets)
51  : TheParser(P), AsmLoc(Loc), AsmString(AsmString), AsmToks(Toks),
52  AsmTokOffsets(Offsets) {
53  assert(AsmToks.size() == AsmTokOffsets.size());
54  }
55 
56  void LookupInlineAsmIdentifier(StringRef &LineBuf,
57  llvm::InlineAsmIdentifierInfo &Info,
58  bool IsUnevaluatedContext) override;
59 
60  StringRef LookupInlineAsmLabel(StringRef Identifier, llvm::SourceMgr &LSM,
61  llvm::SMLoc Location,
62  bool Create) override;
63 
64  bool LookupInlineAsmField(StringRef Base, StringRef Member,
65  unsigned &Offset) override {
66  return TheParser.getActions().LookupInlineAsmField(Base, Member, Offset,
67  AsmLoc);
68  }
69 
70  static void DiagHandlerCallback(const llvm::SMDiagnostic &D, void *Context) {
71  ((ClangAsmParserCallback *)Context)->handleDiagnostic(D);
72  }
73 
74 private:
75  /// Collect the appropriate tokens for the given string.
76  void findTokensForString(StringRef Str, SmallVectorImpl<Token> &TempToks,
77  const Token *&FirstOrigToken) const;
78 
79  SourceLocation translateLocation(const llvm::SourceMgr &LSM,
80  llvm::SMLoc SMLoc);
81 
82  void handleDiagnostic(const llvm::SMDiagnostic &D);
83 };
84 }
85 
86 void ClangAsmParserCallback::LookupInlineAsmIdentifier(
87  StringRef &LineBuf, llvm::InlineAsmIdentifierInfo &Info,
88  bool IsUnevaluatedContext) {
89  // Collect the desired tokens.
90  SmallVector<Token, 16> LineToks;
91  const Token *FirstOrigToken = nullptr;
92  findTokensForString(LineBuf, LineToks, FirstOrigToken);
93 
94  unsigned NumConsumedToks;
95  ExprResult Result = TheParser.ParseMSAsmIdentifier(LineToks, NumConsumedToks,
96  IsUnevaluatedContext);
97 
98  // If we consumed the entire line, tell MC that.
99  // Also do this if we consumed nothing as a way of reporting failure.
100  if (NumConsumedToks == 0 || NumConsumedToks == LineToks.size()) {
101  // By not modifying LineBuf, we're implicitly consuming it all.
102 
103  // Otherwise, consume up to the original tokens.
104  } else {
105  assert(FirstOrigToken && "not using original tokens?");
106 
107  // Since we're using original tokens, apply that offset.
108  assert(FirstOrigToken[NumConsumedToks].getLocation() ==
109  LineToks[NumConsumedToks].getLocation());
110  unsigned FirstIndex = FirstOrigToken - AsmToks.begin();
111  unsigned LastIndex = FirstIndex + NumConsumedToks - 1;
112 
113  // The total length we've consumed is the relative offset
114  // of the last token we consumed plus its length.
115  unsigned TotalOffset =
116  (AsmTokOffsets[LastIndex] + AsmToks[LastIndex].getLength() -
117  AsmTokOffsets[FirstIndex]);
118  LineBuf = LineBuf.substr(0, TotalOffset);
119  }
120 
121  // Initialize Info with the lookup result.
122  if (!Result.isUsable())
123  return;
124  TheParser.getActions().FillInlineAsmIdentifierInfo(Result.get(), Info);
125 }
126 
127 StringRef ClangAsmParserCallback::LookupInlineAsmLabel(StringRef Identifier,
128  llvm::SourceMgr &LSM,
129  llvm::SMLoc Location,
130  bool Create) {
131  SourceLocation Loc = translateLocation(LSM, Location);
132  LabelDecl *Label =
133  TheParser.getActions().GetOrCreateMSAsmLabel(Identifier, Loc, Create);
134  return Label->getMSAsmLabel();
135 }
136 
137 void ClangAsmParserCallback::findTokensForString(
138  StringRef Str, SmallVectorImpl<Token> &TempToks,
139  const Token *&FirstOrigToken) const {
140  // For now, assert that the string we're working with is a substring
141  // of what we gave to MC. This lets us use the original tokens.
142  assert(!std::less<const char *>()(Str.begin(), AsmString.begin()) &&
143  !std::less<const char *>()(AsmString.end(), Str.end()));
144 
145  // Try to find a token whose offset matches the first token.
146  unsigned FirstCharOffset = Str.begin() - AsmString.begin();
147  const unsigned *FirstTokOffset =
148  llvm::lower_bound(AsmTokOffsets, FirstCharOffset);
149 
150  // For now, assert that the start of the string exactly
151  // corresponds to the start of a token.
152  assert(*FirstTokOffset == FirstCharOffset);
153 
154  // Use all the original tokens for this line. (We assume the
155  // end of the line corresponds cleanly to a token break.)
156  unsigned FirstTokIndex = FirstTokOffset - AsmTokOffsets.begin();
157  FirstOrigToken = &AsmToks[FirstTokIndex];
158  unsigned LastCharOffset = Str.end() - AsmString.begin();
159  for (unsigned i = FirstTokIndex, e = AsmTokOffsets.size(); i != e; ++i) {
160  if (AsmTokOffsets[i] >= LastCharOffset)
161  break;
162  TempToks.push_back(AsmToks[i]);
163  }
164 }
165 
167 ClangAsmParserCallback::translateLocation(const llvm::SourceMgr &LSM,
168  llvm::SMLoc SMLoc) {
169  // Compute an offset into the inline asm buffer.
170  // FIXME: This isn't right if .macro is involved (but hopefully, no
171  // real-world code does that).
172  const llvm::MemoryBuffer *LBuf =
173  LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(SMLoc));
174  unsigned Offset = SMLoc.getPointer() - LBuf->getBufferStart();
175 
176  // Figure out which token that offset points into.
177  const unsigned *TokOffsetPtr = llvm::lower_bound(AsmTokOffsets, Offset);
178  unsigned TokIndex = TokOffsetPtr - AsmTokOffsets.begin();
179  unsigned TokOffset = *TokOffsetPtr;
180 
181  // If we come up with an answer which seems sane, use it; otherwise,
182  // just point at the __asm keyword.
183  // FIXME: Assert the answer is sane once we handle .macro correctly.
184  SourceLocation Loc = AsmLoc;
185  if (TokIndex < AsmToks.size()) {
186  const Token &Tok = AsmToks[TokIndex];
187  Loc = Tok.getLocation();
188  Loc = Loc.getLocWithOffset(Offset - TokOffset);
189  }
190  return Loc;
191 }
192 
193 void ClangAsmParserCallback::handleDiagnostic(const llvm::SMDiagnostic &D) {
194  const llvm::SourceMgr &LSM = *D.getSourceMgr();
195  SourceLocation Loc = translateLocation(LSM, D.getLoc());
196  TheParser.Diag(Loc, diag::err_inline_ms_asm_parsing) << D.getMessage();
197 }
198 
199 /// Parse an identifier in an MS-style inline assembly block.
201  unsigned &NumLineToksConsumed,
202  bool IsUnevaluatedContext) {
203  // Push a fake token on the end so that we don't overrun the token
204  // stream. We use ';' because it expression-parsing should never
205  // overrun it.
206  const tok::TokenKind EndOfStream = tok::semi;
207  Token EndOfStreamTok;
208  EndOfStreamTok.startToken();
209  EndOfStreamTok.setKind(EndOfStream);
210  LineToks.push_back(EndOfStreamTok);
211 
212  // Also copy the current token over.
213  LineToks.push_back(Tok);
214 
215  PP.EnterTokenStream(LineToks, /*DisableMacroExpansions*/ true,
216  /*IsReinject*/ true);
217 
218  // Clear the current token and advance to the first token in LineToks.
219  ConsumeAnyToken();
220 
221  // Parse an optional scope-specifier if we're in C++.
222  CXXScopeSpec SS;
223  if (getLangOpts().CPlusPlus)
224  ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
225  /*ObjectHadErrors=*/false,
226  /*EnteringContext=*/false);
227 
228  // Require an identifier here.
229  SourceLocation TemplateKWLoc;
231  bool Invalid = true;
232  ExprResult Result;
233  if (Tok.is(tok::kw_this)) {
234  Result = ParseCXXThis();
235  Invalid = false;
236  } else {
237  Invalid =
238  ParseUnqualifiedId(SS, /*ObjectType=*/nullptr,
239  /*ObjectHadErrors=*/false,
240  /*EnteringContext=*/false,
241  /*AllowDestructorName=*/false,
242  /*AllowConstructorName=*/false,
243  /*AllowDeductionGuide=*/false, &TemplateKWLoc, Id);
244  // Perform the lookup.
245  Result = Actions.LookupInlineAsmIdentifier(SS, TemplateKWLoc, Id,
246  IsUnevaluatedContext);
247  }
248  // While the next two tokens are 'period' 'identifier', repeatedly parse it as
249  // a field access. We have to avoid consuming assembler directives that look
250  // like '.' 'else'.
251  while (Result.isUsable() && Tok.is(tok::period)) {
252  Token IdTok = PP.LookAhead(0);
253  if (IdTok.isNot(tok::identifier))
254  break;
255  ConsumeToken(); // Consume the period.
257  ConsumeToken(); // Consume the identifier.
258  Result = Actions.LookupInlineAsmVarDeclField(Result.get(), Id->getName(),
259  Tok.getLocation());
260  }
261 
262  // Figure out how many tokens we are into LineToks.
263  unsigned LineIndex = 0;
264  if (Tok.is(EndOfStream)) {
265  LineIndex = LineToks.size() - 2;
266  } else {
267  while (LineToks[LineIndex].getLocation() != Tok.getLocation()) {
268  LineIndex++;
269  assert(LineIndex < LineToks.size() - 2); // we added two extra tokens
270  }
271  }
272 
273  // If we've run into the poison token we inserted before, or there
274  // was a parsing error, then claim the entire line.
275  if (Invalid || Tok.is(EndOfStream)) {
276  NumLineToksConsumed = LineToks.size() - 2;
277  } else {
278  // Otherwise, claim up to the start of the next token.
279  NumLineToksConsumed = LineIndex;
280  }
281 
282  // Finally, restore the old parsing state by consuming all the tokens we
283  // staged before, implicitly killing off the token-lexer we pushed.
284  for (unsigned i = 0, e = LineToks.size() - LineIndex - 2; i != e; ++i) {
285  ConsumeAnyToken();
286  }
287  assert(Tok.is(EndOfStream));
288  ConsumeToken();
289 
290  // Leave LineToks in its original state.
291  LineToks.pop_back();
292  LineToks.pop_back();
293 
294  return Result;
295 }
296 
297 /// Turn a sequence of our tokens back into a string that we can hand
298 /// to the MC asm parser.
300  ArrayRef<Token> AsmToks,
301  SmallVectorImpl<unsigned> &TokOffsets,
302  SmallString<512> &Asm) {
303  assert(!AsmToks.empty() && "Didn't expect an empty AsmToks!");
304 
305  // Is this the start of a new assembly statement?
306  bool isNewStatement = true;
307 
308  for (unsigned i = 0, e = AsmToks.size(); i < e; ++i) {
309  const Token &Tok = AsmToks[i];
310 
311  // Start each new statement with a newline and a tab.
312  if (!isNewStatement && (Tok.is(tok::kw_asm) || Tok.isAtStartOfLine())) {
313  Asm += "\n\t";
314  isNewStatement = true;
315  }
316 
317  // Preserve the existence of leading whitespace except at the
318  // start of a statement.
319  if (!isNewStatement && Tok.hasLeadingSpace())
320  Asm += ' ';
321 
322  // Remember the offset of this token.
323  TokOffsets.push_back(Asm.size());
324 
325  // Don't actually write '__asm' into the assembly stream.
326  if (Tok.is(tok::kw_asm)) {
327  // Complain about __asm at the end of the stream.
328  if (i + 1 == e) {
329  PP.Diag(AsmLoc, diag::err_asm_empty);
330  return true;
331  }
332 
333  continue;
334  }
335 
336  // Append the spelling of the token.
337  SmallString<32> SpellingBuffer;
338  bool SpellingInvalid = false;
339  Asm += PP.getSpelling(Tok, SpellingBuffer, &SpellingInvalid);
340  assert(!SpellingInvalid && "spelling was invalid after correct parse?");
341 
342  // We are no longer at the start of a statement.
343  isNewStatement = false;
344  }
345 
346  // Ensure that the buffer is null-terminated.
347  Asm.push_back('\0');
348  Asm.pop_back();
349 
350  assert(TokOffsets.size() == AsmToks.size());
351  return false;
352 }
353 
354 // Determine if this is a GCC-style asm statement.
355 bool Parser::isGCCAsmStatement(const Token &TokAfterAsm) const {
356  return TokAfterAsm.is(tok::l_paren) || isGNUAsmQualifier(TokAfterAsm);
357 }
358 
359 bool Parser::isGNUAsmQualifier(const Token &TokAfterAsm) const {
360  return getGNUAsmQualifier(TokAfterAsm) != GNUAsmQualifiers::AQ_unspecified;
361 }
362 
363 /// ParseMicrosoftAsmStatement. When -fms-extensions/-fasm-blocks is enabled,
364 /// this routine is called to collect the tokens for an MS asm statement.
365 ///
366 /// [MS] ms-asm-statement:
367 /// ms-asm-block
368 /// ms-asm-block ms-asm-statement
369 ///
370 /// [MS] ms-asm-block:
371 /// '__asm' ms-asm-line '\n'
372 /// '__asm' '{' ms-asm-instruction-block[opt] '}' ';'[opt]
373 ///
374 /// [MS] ms-asm-instruction-block
375 /// ms-asm-line
376 /// ms-asm-line '\n' ms-asm-instruction-block
377 ///
378 StmtResult Parser::ParseMicrosoftAsmStatement(SourceLocation AsmLoc) {
379  SourceManager &SrcMgr = PP.getSourceManager();
380  SourceLocation EndLoc = AsmLoc;
381  SmallVector<Token, 4> AsmToks;
382 
383  bool SingleLineMode = true;
384  unsigned BraceNesting = 0;
385  unsigned short savedBraceCount = BraceCount;
386  bool InAsmComment = false;
387  FileID FID;
388  unsigned LineNo = 0;
389  unsigned NumTokensRead = 0;
391  bool SkippedStartOfLine = false;
392 
393  if (Tok.is(tok::l_brace)) {
394  // Braced inline asm: consume the opening brace.
395  SingleLineMode = false;
396  BraceNesting = 1;
397  EndLoc = ConsumeBrace();
398  LBraceLocs.push_back(EndLoc);
399  ++NumTokensRead;
400  } else {
401  // Single-line inline asm; compute which line it is on.
402  std::pair<FileID, unsigned> ExpAsmLoc =
403  SrcMgr.getDecomposedExpansionLoc(EndLoc);
404  FID = ExpAsmLoc.first;
405  LineNo = SrcMgr.getLineNumber(FID, ExpAsmLoc.second);
406  LBraceLocs.push_back(SourceLocation());
407  }
408 
409  SourceLocation TokLoc = Tok.getLocation();
410  do {
411  // If we hit EOF, we're done, period.
412  if (isEofOrEom())
413  break;
414 
415  if (!InAsmComment && Tok.is(tok::l_brace)) {
416  // Consume the opening brace.
417  SkippedStartOfLine = Tok.isAtStartOfLine();
418  AsmToks.push_back(Tok);
419  EndLoc = ConsumeBrace();
420  BraceNesting++;
421  LBraceLocs.push_back(EndLoc);
422  TokLoc = Tok.getLocation();
423  ++NumTokensRead;
424  continue;
425  } else if (!InAsmComment && Tok.is(tok::semi)) {
426  // A semicolon in an asm is the start of a comment.
427  InAsmComment = true;
428  if (!SingleLineMode) {
429  // Compute which line the comment is on.
430  std::pair<FileID, unsigned> ExpSemiLoc =
431  SrcMgr.getDecomposedExpansionLoc(TokLoc);
432  FID = ExpSemiLoc.first;
433  LineNo = SrcMgr.getLineNumber(FID, ExpSemiLoc.second);
434  }
435  } else if (SingleLineMode || InAsmComment) {
436  // If end-of-line is significant, check whether this token is on a
437  // new line.
438  std::pair<FileID, unsigned> ExpLoc =
439  SrcMgr.getDecomposedExpansionLoc(TokLoc);
440  if (ExpLoc.first != FID ||
441  SrcMgr.getLineNumber(ExpLoc.first, ExpLoc.second) != LineNo) {
442  // If this is a single-line __asm, we're done, except if the next
443  // line is MS-style asm too, in which case we finish a comment
444  // if needed and then keep processing the next line as a single
445  // line __asm.
446  bool isAsm = Tok.is(tok::kw_asm);
447  if (SingleLineMode && (!isAsm || isGCCAsmStatement(NextToken())))
448  break;
449  // We're no longer in a comment.
450  InAsmComment = false;
451  if (isAsm) {
452  // If this is a new __asm {} block we want to process it separately
453  // from the single-line __asm statements
454  if (PP.LookAhead(0).is(tok::l_brace))
455  break;
456  LineNo = SrcMgr.getLineNumber(ExpLoc.first, ExpLoc.second);
457  SkippedStartOfLine = Tok.isAtStartOfLine();
458  } else if (Tok.is(tok::semi)) {
459  // A multi-line asm-statement, where next line is a comment
460  InAsmComment = true;
461  FID = ExpLoc.first;
462  LineNo = SrcMgr.getLineNumber(FID, ExpLoc.second);
463  }
464  } else if (!InAsmComment && Tok.is(tok::r_brace)) {
465  // In MSVC mode, braces only participate in brace matching and
466  // separating the asm statements. This is an intentional
467  // departure from the Apple gcc behavior.
468  if (!BraceNesting)
469  break;
470  }
471  }
472  if (!InAsmComment && BraceNesting && Tok.is(tok::r_brace) &&
473  BraceCount == (savedBraceCount + BraceNesting)) {
474  // Consume the closing brace.
475  SkippedStartOfLine = Tok.isAtStartOfLine();
476  // Don't want to add the closing brace of the whole asm block
477  if (SingleLineMode || BraceNesting > 1) {
479  AsmToks.push_back(Tok);
480  }
481  EndLoc = ConsumeBrace();
482  BraceNesting--;
483  // Finish if all of the opened braces in the inline asm section were
484  // consumed.
485  if (BraceNesting == 0 && !SingleLineMode)
486  break;
487  else {
488  LBraceLocs.pop_back();
489  TokLoc = Tok.getLocation();
490  ++NumTokensRead;
491  continue;
492  }
493  }
494 
495  // Consume the next token; make sure we don't modify the brace count etc.
496  // if we are in a comment.
497  EndLoc = TokLoc;
498  if (InAsmComment)
499  PP.Lex(Tok);
500  else {
501  // Set the token as the start of line if we skipped the original start
502  // of line token in case it was a nested brace.
503  if (SkippedStartOfLine)
505  AsmToks.push_back(Tok);
506  ConsumeAnyToken();
507  }
508  TokLoc = Tok.getLocation();
509  ++NumTokensRead;
510  SkippedStartOfLine = false;
511  } while (1);
512 
513  if (BraceNesting && BraceCount != savedBraceCount) {
514  // __asm without closing brace (this can happen at EOF).
515  for (unsigned i = 0; i < BraceNesting; ++i) {
516  Diag(Tok, diag::err_expected) << tok::r_brace;
517  Diag(LBraceLocs.back(), diag::note_matching) << tok::l_brace;
518  LBraceLocs.pop_back();
519  }
520  return StmtError();
521  } else if (NumTokensRead == 0) {
522  // Empty __asm.
523  Diag(Tok, diag::err_expected) << tok::l_brace;
524  return StmtError();
525  }
526 
527  // Okay, prepare to use MC to parse the assembly.
528  SmallVector<StringRef, 4> ConstraintRefs;
530  SmallVector<StringRef, 4> ClobberRefs;
531 
532  // We need an actual supported target.
533  const llvm::Triple &TheTriple = Actions.Context.getTargetInfo().getTriple();
534  const std::string &TT = TheTriple.getTriple();
535  const llvm::Target *TheTarget = nullptr;
536  if (!TheTriple.isX86()) {
537  Diag(AsmLoc, diag::err_msasm_unsupported_arch) << TheTriple.getArchName();
538  } else {
540  TheTarget = llvm::TargetRegistry::lookupTarget(TT, Error);
541  if (!TheTarget)
542  Diag(AsmLoc, diag::err_msasm_unable_to_create_target) << Error;
543  }
544 
545  assert(!LBraceLocs.empty() && "Should have at least one location here");
546 
547  SmallString<512> AsmString;
548  auto EmptyStmt = [&] {
549  return Actions.ActOnMSAsmStmt(AsmLoc, LBraceLocs[0], AsmToks, AsmString,
550  /*NumOutputs*/ 0, /*NumInputs*/ 0,
551  ConstraintRefs, ClobberRefs, Exprs, EndLoc);
552  };
553  // If we don't support assembly, or the assembly is empty, we don't
554  // need to instantiate the AsmParser, etc.
555  if (!TheTarget || AsmToks.empty()) {
556  return EmptyStmt();
557  }
558 
559  // Expand the tokens into a string buffer.
560  SmallVector<unsigned, 8> TokOffsets;
561  if (buildMSAsmString(PP, AsmLoc, AsmToks, TokOffsets, AsmString))
562  return StmtError();
563 
564  const TargetOptions &TO = Actions.Context.getTargetInfo().getTargetOpts();
565  std::string FeaturesStr =
566  llvm::join(TO.Features.begin(), TO.Features.end(), ",");
567 
568  std::unique_ptr<llvm::MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TT));
569  if (!MRI) {
570  Diag(AsmLoc, diag::err_msasm_unable_to_create_target)
571  << "target MC unavailable";
572  return EmptyStmt();
573  }
574  // FIXME: init MCOptions from sanitizer flags here.
575  llvm::MCTargetOptions MCOptions;
576  std::unique_ptr<llvm::MCAsmInfo> MAI(
577  TheTarget->createMCAsmInfo(*MRI, TT, MCOptions));
578  // Get the instruction descriptor.
579  std::unique_ptr<llvm::MCInstrInfo> MII(TheTarget->createMCInstrInfo());
580  std::unique_ptr<llvm::MCSubtargetInfo> STI(
581  TheTarget->createMCSubtargetInfo(TT, TO.CPU, FeaturesStr));
582  // Target MCTargetDesc may not be linked in clang-based tools.
583 
584  if (!MAI || !MII || !STI) {
585  Diag(AsmLoc, diag::err_msasm_unable_to_create_target)
586  << "target MC unavailable";
587  return EmptyStmt();
588  }
589 
590  llvm::SourceMgr TempSrcMgr;
591  llvm::MCContext Ctx(TheTriple, MAI.get(), MRI.get(), STI.get(), &TempSrcMgr);
592  std::unique_ptr<llvm::MCObjectFileInfo> MOFI(
593  TheTarget->createMCObjectFileInfo(Ctx, /*PIC=*/false));
594  Ctx.setObjectFileInfo(MOFI.get());
595 
596  std::unique_ptr<llvm::MemoryBuffer> Buffer =
597  llvm::MemoryBuffer::getMemBuffer(AsmString, "<MS inline asm>");
598 
599  // Tell SrcMgr about this buffer, which is what the parser will pick up.
600  TempSrcMgr.AddNewSourceBuffer(std::move(Buffer), llvm::SMLoc());
601 
602  std::unique_ptr<llvm::MCStreamer> Str(createNullStreamer(Ctx));
603  std::unique_ptr<llvm::MCAsmParser> Parser(
604  createMCAsmParser(TempSrcMgr, Ctx, *Str.get(), *MAI));
605 
606  std::unique_ptr<llvm::MCTargetAsmParser> TargetParser(
607  TheTarget->createMCAsmParser(*STI, *Parser, *MII, MCOptions));
608  // Target AsmParser may not be linked in clang-based tools.
609  if (!TargetParser) {
610  Diag(AsmLoc, diag::err_msasm_unable_to_create_target)
611  << "target ASM parser unavailable";
612  return EmptyStmt();
613  }
614 
615  std::unique_ptr<llvm::MCInstPrinter> IP(
616  TheTarget->createMCInstPrinter(llvm::Triple(TT), 1, *MAI, *MII, *MRI));
617 
618  // Change to the Intel dialect.
619  Parser->setAssemblerDialect(1);
620  Parser->setTargetParser(*TargetParser.get());
621  Parser->setParsingMSInlineAsm(true);
622  TargetParser->setParsingMSInlineAsm(true);
623 
624  ClangAsmParserCallback Callback(*this, AsmLoc, AsmString, AsmToks,
625  TokOffsets);
626  TargetParser->setSemaCallback(&Callback);
627  TempSrcMgr.setDiagHandler(ClangAsmParserCallback::DiagHandlerCallback,
628  &Callback);
629 
630  unsigned NumOutputs;
631  unsigned NumInputs;
632  std::string AsmStringIR;
634  SmallVector<std::string, 4> Constraints;
636  if (Parser->parseMSInlineAsm(AsmStringIR, NumOutputs, NumInputs, OpExprs,
637  Constraints, Clobbers, MII.get(), IP.get(),
638  Callback))
639  return StmtError();
640 
641  // Filter out "fpsw" and "mxcsr". They aren't valid GCC asm clobber
642  // constraints. Clang always adds fpsr to the clobber list anyway.
643  llvm::erase_if(Clobbers, [](const std::string &C) {
644  return C == "fpsr" || C == "mxcsr";
645  });
646 
647  // Build the vector of clobber StringRefs.
648  ClobberRefs.insert(ClobberRefs.end(), Clobbers.begin(), Clobbers.end());
649 
650  // Recast the void pointers and build the vector of constraint StringRefs.
651  unsigned NumExprs = NumOutputs + NumInputs;
652  ConstraintRefs.resize(NumExprs);
653  Exprs.resize(NumExprs);
654  for (unsigned i = 0, e = NumExprs; i != e; ++i) {
655  Expr *OpExpr = static_cast<Expr *>(OpExprs[i].first);
656  if (!OpExpr)
657  return StmtError();
658 
659  // Need address of variable.
660  if (OpExprs[i].second)
661  OpExpr =
662  Actions.BuildUnaryOp(getCurScope(), AsmLoc, UO_AddrOf, OpExpr).get();
663 
664  ConstraintRefs[i] = StringRef(Constraints[i]);
665  Exprs[i] = OpExpr;
666  }
667 
668  // FIXME: We should be passing source locations for better diagnostics.
669  return Actions.ActOnMSAsmStmt(AsmLoc, LBraceLocs[0], AsmToks, AsmStringIR,
670  NumOutputs, NumInputs, ConstraintRefs,
671  ClobberRefs, Exprs, EndLoc);
672 }
673 
674 /// parseGNUAsmQualifierListOpt - Parse a GNU extended asm qualifier list.
675 /// asm-qualifier:
676 /// volatile
677 /// inline
678 /// goto
679 ///
680 /// asm-qualifier-list:
681 /// asm-qualifier
682 /// asm-qualifier-list asm-qualifier
683 bool Parser::parseGNUAsmQualifierListOpt(GNUAsmQualifiers &AQ) {
684  while (1) {
685  const GNUAsmQualifiers::AQ A = getGNUAsmQualifier(Tok);
686  if (A == GNUAsmQualifiers::AQ_unspecified) {
687  if (Tok.isNot(tok::l_paren)) {
688  Diag(Tok.getLocation(), diag::err_asm_qualifier_ignored);
689  SkipUntil(tok::r_paren, StopAtSemi);
690  return true;
691  }
692  return false;
693  }
694  if (AQ.setAsmQualifier(A))
695  Diag(Tok.getLocation(), diag::err_asm_duplicate_qual)
696  << GNUAsmQualifiers::getQualifierName(A);
697  ConsumeToken();
698  }
699  return false;
700 }
701 
702 /// ParseAsmStatement - Parse a GNU extended asm statement.
703 /// asm-statement:
704 /// gnu-asm-statement
705 /// ms-asm-statement
706 ///
707 /// [GNU] gnu-asm-statement:
708 /// 'asm' asm-qualifier-list[opt] '(' asm-argument ')' ';'
709 ///
710 /// [GNU] asm-argument:
711 /// asm-string-literal
712 /// asm-string-literal ':' asm-operands[opt]
713 /// asm-string-literal ':' asm-operands[opt] ':' asm-operands[opt]
714 /// asm-string-literal ':' asm-operands[opt] ':' asm-operands[opt]
715 /// ':' asm-clobbers
716 ///
717 /// [GNU] asm-clobbers:
718 /// asm-string-literal
719 /// asm-clobbers ',' asm-string-literal
720 ///
721 StmtResult Parser::ParseAsmStatement(bool &msAsm) {
722  assert(Tok.is(tok::kw_asm) && "Not an asm stmt");
723  SourceLocation AsmLoc = ConsumeToken();
724 
725  if (getLangOpts().AsmBlocks && !isGCCAsmStatement(Tok)) {
726  msAsm = true;
727  return ParseMicrosoftAsmStatement(AsmLoc);
728  }
729 
730  SourceLocation Loc = Tok.getLocation();
731  GNUAsmQualifiers GAQ;
732  if (parseGNUAsmQualifierListOpt(GAQ))
733  return StmtError();
734 
735  if (GAQ.isGoto() && getLangOpts().SpeculativeLoadHardening)
736  Diag(Loc, diag::warn_slh_does_not_support_asm_goto);
737 
738  BalancedDelimiterTracker T(*this, tok::l_paren);
739  T.consumeOpen();
740 
741  ExprResult AsmString(ParseAsmStringLiteral(/*ForAsmLabel*/ false));
742 
743  // Check if GNU-style InlineAsm is disabled.
744  // Error on anything other than empty string.
745  if (!(getLangOpts().GNUAsm || AsmString.isInvalid())) {
746  const auto *SL = cast<StringLiteral>(AsmString.get());
747  if (!SL->getString().trim().empty())
748  Diag(Loc, diag::err_gnu_inline_asm_disabled);
749  }
750 
751  if (AsmString.isInvalid()) {
752  // Consume up to and including the closing paren.
753  T.skipToEnd();
754  return StmtError();
755  }
756 
758  ExprVector Constraints;
759  ExprVector Exprs;
760  ExprVector Clobbers;
761 
762  if (Tok.is(tok::r_paren)) {
763  // We have a simple asm expression like 'asm("foo")'.
764  T.consumeClose();
765  return Actions.ActOnGCCAsmStmt(
766  AsmLoc, /*isSimple*/ true, GAQ.isVolatile(),
767  /*NumOutputs*/ 0, /*NumInputs*/ 0, nullptr, Constraints, Exprs,
768  AsmString.get(), Clobbers, /*NumLabels*/ 0, T.getCloseLocation());
769  }
770 
771  // Parse Outputs, if present.
772  bool AteExtraColon = false;
773  if (Tok.is(tok::colon) || Tok.is(tok::coloncolon)) {
774  // In C++ mode, parse "::" like ": :".
775  AteExtraColon = Tok.is(tok::coloncolon);
776  ConsumeToken();
777 
778  if (!AteExtraColon && ParseAsmOperandsOpt(Names, Constraints, Exprs))
779  return StmtError();
780  }
781 
782  unsigned NumOutputs = Names.size();
783 
784  // Parse Inputs, if present.
785  if (AteExtraColon || Tok.is(tok::colon) || Tok.is(tok::coloncolon)) {
786  // In C++ mode, parse "::" like ": :".
787  if (AteExtraColon)
788  AteExtraColon = false;
789  else {
790  AteExtraColon = Tok.is(tok::coloncolon);
791  ConsumeToken();
792  }
793 
794  if (!AteExtraColon && ParseAsmOperandsOpt(Names, Constraints, Exprs))
795  return StmtError();
796  }
797 
798  assert(Names.size() == Constraints.size() &&
799  Constraints.size() == Exprs.size() && "Input operand size mismatch!");
800 
801  unsigned NumInputs = Names.size() - NumOutputs;
802 
803  // Parse the clobbers, if present.
804  if (AteExtraColon || Tok.is(tok::colon) || Tok.is(tok::coloncolon)) {
805  if (AteExtraColon)
806  AteExtraColon = false;
807  else {
808  AteExtraColon = Tok.is(tok::coloncolon);
809  ConsumeToken();
810  }
811  // Parse the asm-string list for clobbers if present.
812  if (!AteExtraColon && isTokenStringLiteral()) {
813  while (1) {
814  ExprResult Clobber(ParseAsmStringLiteral(/*ForAsmLabel*/ false));
815 
816  if (Clobber.isInvalid())
817  break;
818 
819  Clobbers.push_back(Clobber.get());
820 
821  if (!TryConsumeToken(tok::comma))
822  break;
823  }
824  }
825  }
826  if (!GAQ.isGoto() && (Tok.isNot(tok::r_paren) || AteExtraColon)) {
827  Diag(Tok, diag::err_expected) << tok::r_paren;
828  SkipUntil(tok::r_paren, StopAtSemi);
829  return StmtError();
830  }
831 
832  // Parse the goto label, if present.
833  unsigned NumLabels = 0;
834  if (AteExtraColon || Tok.is(tok::colon)) {
835  if (!AteExtraColon)
836  ConsumeToken();
837 
838  while (true) {
839  if (Tok.isNot(tok::identifier)) {
840  Diag(Tok, diag::err_expected) << tok::identifier;
841  SkipUntil(tok::r_paren, StopAtSemi);
842  return StmtError();
843  }
844  LabelDecl *LD = Actions.LookupOrCreateLabel(Tok.getIdentifierInfo(),
845  Tok.getLocation());
846  Names.push_back(Tok.getIdentifierInfo());
847  if (!LD) {
848  SkipUntil(tok::r_paren, StopAtSemi);
849  return StmtError();
850  }
851  ExprResult Res =
852  Actions.ActOnAddrLabel(Tok.getLocation(), Tok.getLocation(), LD);
853  Exprs.push_back(Res.get());
854  NumLabels++;
855  ConsumeToken();
856  if (!TryConsumeToken(tok::comma))
857  break;
858  }
859  } else if (GAQ.isGoto()) {
860  Diag(Tok, diag::err_expected) << tok::colon;
861  SkipUntil(tok::r_paren, StopAtSemi);
862  return StmtError();
863  }
864  T.consumeClose();
865  return Actions.ActOnGCCAsmStmt(AsmLoc, false, GAQ.isVolatile(), NumOutputs,
866  NumInputs, Names.data(), Constraints, Exprs,
867  AsmString.get(), Clobbers, NumLabels,
868  T.getCloseLocation());
869 }
870 
871 /// ParseAsmOperands - Parse the asm-operands production as used by
872 /// asm-statement, assuming the leading ':' token was eaten.
873 ///
874 /// [GNU] asm-operands:
875 /// asm-operand
876 /// asm-operands ',' asm-operand
877 ///
878 /// [GNU] asm-operand:
879 /// asm-string-literal '(' expression ')'
880 /// '[' identifier ']' asm-string-literal '(' expression ')'
881 ///
882 //
883 // FIXME: Avoid unnecessary std::string trashing.
884 bool Parser::ParseAsmOperandsOpt(SmallVectorImpl<IdentifierInfo *> &Names,
885  SmallVectorImpl<Expr *> &Constraints,
886  SmallVectorImpl<Expr *> &Exprs) {
887  // 'asm-operands' isn't present?
888  if (!isTokenStringLiteral() && Tok.isNot(tok::l_square))
889  return false;
890 
891  while (1) {
892  // Read the [id] if present.
893  if (Tok.is(tok::l_square)) {
894  BalancedDelimiterTracker T(*this, tok::l_square);
895  T.consumeOpen();
896 
897  if (Tok.isNot(tok::identifier)) {
898  Diag(Tok, diag::err_expected) << tok::identifier;
899  SkipUntil(tok::r_paren, StopAtSemi);
900  return true;
901  }
902 
903  IdentifierInfo *II = Tok.getIdentifierInfo();
904  ConsumeToken();
905 
906  Names.push_back(II);
907  T.consumeClose();
908  } else
909  Names.push_back(nullptr);
910 
911  ExprResult Constraint(ParseAsmStringLiteral(/*ForAsmLabel*/ false));
912  if (Constraint.isInvalid()) {
913  SkipUntil(tok::r_paren, StopAtSemi);
914  return true;
915  }
916  Constraints.push_back(Constraint.get());
917 
918  if (Tok.isNot(tok::l_paren)) {
919  Diag(Tok, diag::err_expected_lparen_after) << "asm operand";
920  SkipUntil(tok::r_paren, StopAtSemi);
921  return true;
922  }
923 
924  // Read the parenthesized expression.
925  BalancedDelimiterTracker T(*this, tok::l_paren);
926  T.consumeOpen();
928  T.consumeClose();
929  if (Res.isInvalid()) {
930  SkipUntil(tok::r_paren, StopAtSemi);
931  return true;
932  }
933  Exprs.push_back(Res.get());
934  // Eat the comma and continue parsing if it exists.
935  if (!TryConsumeToken(tok::comma))
936  return false;
937  }
938 }
939 
940 const char *Parser::GNUAsmQualifiers::getQualifierName(AQ Qualifier) {
941  switch (Qualifier) {
942  case AQ_volatile: return "volatile";
943  case AQ_inline: return "inline";
944  case AQ_goto: return "goto";
945  case AQ_unspecified: return "unspecified";
946  }
947  llvm_unreachable("Unknown GNUAsmQualifier");
948 }
949 
950 Parser::GNUAsmQualifiers::AQ
951 Parser::getGNUAsmQualifier(const Token &Tok) const {
952  switch (Tok.getKind()) {
953  case tok::kw_volatile: return GNUAsmQualifiers::AQ_volatile;
954  case tok::kw_inline: return GNUAsmQualifiers::AQ_inline;
955  case tok::kw_goto: return GNUAsmQualifiers::AQ_goto;
956  default: return GNUAsmQualifiers::AQ_unspecified;
957  }
958 }
959 bool Parser::GNUAsmQualifiers::setAsmQualifier(AQ Qualifier) {
960  bool IsDuplicate = Qualifiers & Qualifier;
962  return IsDuplicate;
963 }
clang::Token::startToken
void startToken()
Reset all flags to cleared.
Definition: Token.h:171
clang::UnqualifiedId
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:951
clang::Token::hasLeadingSpace
bool hasLeadingSpace() const
Return true if this token has whitespace before it.
Definition: Token.h:272
clang::Preprocessor::LookAhead
const Token & LookAhead(unsigned N)
Peeks ahead N tokens and returns that token without consuming any tokens.
Definition: Preprocessor.h:1529
Error
llvm::Error Error
Definition: ByteCodeEmitter.cpp:20
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::Preprocessor::Lex
void Lex(Token &Result)
Lex the next token for this preprocessor.
Definition: Preprocessor.cpp:888
clang::Parser::SkipUntil
bool SkipUntil(tok::TokenKind T, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
SkipUntil - Read tokens until we get to the specified token, then consume it (unless StopBeforeMatch ...
Definition: Parser.h:1205
llvm::SmallVector
Definition: LLVM.h:38
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:88
clang::SourceLocation::getLocWithOffset
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
Definition: SourceLocation.h:136
TargetInfo.h
AttributeLangSupport::C
@ C
Definition: SemaDeclAttr.cpp:54
clang::Token::getIdentifierInfo
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:179
clang::Qualifiers
The collection of all-type qualifiers we support.
Definition: Type.h:145
clang::Token::isAtStartOfLine
bool isAtStartOfLine() const
isAtStartOfLine - Return true if this token is at the start of a line.
Definition: Token.h:268
clang::Parser
Parser - This implements a parser for the C family of languages.
Definition: Parser.h:60
RAIIObjectsForParser.h
clang::CXXScopeSpec
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:64
clang::Language::Asm
@ Asm
Assembly: we accept this only so that we can preprocess it.
Identifier
StringRef Identifier
Definition: Format.cpp:2341
clang::Token
Token - This structure provides full information about a lexed token.
Definition: Token.h:34
clang::BalancedDelimiterTracker
RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ....
Definition: RAIIObjectsForParser.h:385
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:626
clang::Sema::ActOnGCCAsmStmt
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)
Definition: SemaStmtAsm.cpp:241
clang::Sema::Context
ASTContext & Context
Definition: Sema.h:411
Offset
unsigned Offset
Definition: Format.cpp:2335
Id
int Id
Definition: ASTDiff.cpp:191
clang::Parser::ParseUnqualifiedId
bool ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors, bool EnteringContext, bool AllowDestructorName, bool AllowConstructorName, bool AllowDeductionGuide, SourceLocation *TemplateKWLoc, UnqualifiedId &Result)
Parse a C++ unqualified-id (or a C identifier), which describes the name of an entity.
Definition: ParseExprCXX.cpp:2780
clang::Token::getKind
tok::TokenKind getKind() const
Definition: Token.h:92
clang::CPlusPlus
@ CPlusPlus
Definition: LangStandard.h:48
clang::syntax::NodeRole::Qualifier
@ Qualifier
Diagnostic.h
clang::Preprocessor::Diag
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
Definition: Preprocessor.h:1744
clang::Parser::getLangOpts
const LangOptions & getLangOpts() const
Definition: Parser.h:437
clang::LabelDecl
Represents the declaration of a label.
Definition: Decl.h:496
clang::Token::is
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....
Definition: Token.h:97
clang::Parser::ParseExpression
ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)
Simple precedence-based parser for binary/ternary operators.
Definition: ParseExpr.cpp:123
clang::Parser::ConsumeAnyToken
SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok=false)
ConsumeAnyToken - Dispatch to the right Consume* method based on the current token type.
Definition: Parser.h:510
llvm::SmallString< 512 >
ASTContext.h
Base
clang::Parser::getCurScope
Scope * getCurScope() const
Definition: Parser.h:444
Label
std::string Label
Definition: UsingDeclarationsSorter.cpp:69
clang::Parser::Diag
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Definition: Parser.cpp:73
clang::Token::isNot
bool isNot(tok::TokenKind K) const
Definition: Token.h:98
clang::Parser::StopAtSemi
@ StopAtSemi
Stop skipping at semicolon.
Definition: Parser.h:1184
clang::Token::LeadingSpace
@ LeadingSpace
Definition: Token.h:75
clang::Preprocessor::getSourceManager
SourceManager & getSourceManager() const
Definition: Preprocessor.h:964
clang::TargetInfo::getTriple
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:1130
clang::TargetOptions::Features
std::vector< std::string > Features
The list of target specific features to enable or disable – this should be a list of strings starting...
Definition: TargetOptions.h:58
clang::Preprocessor::getSpelling
StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const
Return the 'spelling' of the token at the given location; does not go up to the spelling location or ...
Definition: Preprocessor.h:1759
clang::Sema::LookupInlineAsmIdentifier
ExprResult LookupInlineAsmIdentifier(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool IsUnevaluatedContext)
Definition: SemaStmtAsm.cpp:759
clang::tok::TokenKind
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
P
StringRef P
Definition: ASTMatchersInternal.cpp:563
clang::TargetInfo::getTargetOpts
TargetOptions & getTargetOpts() const
Retrieve the target options.
Definition: TargetInfo.h:258
clang::Parser::ConsumeToken
SourceLocation ConsumeToken()
ConsumeToken - Consume the current 'peek token' and lex the next one.
Definition: Parser.h:482
clang::ActionResult::get
PtrTy get() const
Definition: Ownership.h:169
llvm::ArrayRef
Definition: LLVM.h:34
clang::Sema::LookupInlineAsmField
bool LookupInlineAsmField(StringRef Base, StringRef Member, unsigned &Offset, SourceLocation AsmLoc)
Definition: SemaStmtAsm.cpp:806
clang::ActionResult::isInvalid
bool isInvalid() const
Definition: Ownership.h:165
clang::Sema::BuildUnaryOp
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input)
Definition: SemaExpr.cpp:15067
clang::Token::StartOfLine
@ StartOfLine
Definition: Token.h:73
clang::Parser::TryConsumeToken
bool TryConsumeToken(tok::TokenKind Expected)
Definition: Parser.h:490
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:84
clang::Token::clearFlag
void clearFlag(TokenFlags Flag)
Unset the specified flag.
Definition: Token.h:246
clang::Token::getLocation
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file.
Definition: Token.h:126
clang::ASTContext::getTargetInfo
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:747
clang::TargetOptions::CPU
std::string CPU
If given, the name of the target CPU to generate code for.
Definition: TargetOptions.h:36
clang::ActionResult
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc.
Definition: Ownership.h:152
clang::Sema::GetOrCreateMSAsmLabel
LabelDecl * GetOrCreateMSAsmLabel(StringRef ExternalLabelName, SourceLocation Location, bool AlwaysCreate)
Definition: SemaStmtAsm.cpp:942
clang::StmtResult
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:263
clang
Definition: CalledOnceCheck.h:17
clang::Parser::getActions
Sema & getActions() const
Definition: Parser.h:440
clang::Sema::LookupOrCreateLabel
LabelDecl * LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc, SourceLocation GnuLabelLoc=SourceLocation())
LookupOrCreateLabel - Do a name lookup of a label with the specified name.
Definition: SemaLookup.cpp:4102
clang::FileID
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Definition: SourceLocation.h:40
clang::Token::setKind
void setKind(tok::TokenKind K)
Definition: Token.h:93
clang::Sema::ActOnAddrLabel
ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, LabelDecl *TheDecl)
ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
Definition: SemaExpr.cpp:15117
clang::Sema::LookupInlineAsmVarDeclField
ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member, SourceLocation AsmLoc)
Definition: SemaStmtAsm.cpp:875
clang::Sema::ActOnMSAsmStmt
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)
Definition: SemaStmtAsm.cpp:915
clang::Token::setFlag
void setFlag(TokenFlags Flag)
Set the specified flag.
Definition: Token.h:236
clang::TargetOptions
Options for controlling the target.
Definition: TargetOptions.h:26
llvm::SmallVectorImpl
Definition: LLVM.h:39
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:130
clang::SourceManager::getDecomposedExpansionLoc
std::pair< FileID, unsigned > getDecomposedExpansionLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
Definition: SourceManager.h:1249
clang::Parser::NextToken
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
Definition: Parser.h:793
clang::Parser::Parser
Parser(Preprocessor &PP, Sema &Actions, bool SkipFunctionBodies)
Definition: Parser.cpp:51
buildMSAsmString
static bool buildMSAsmString(Preprocessor &PP, SourceLocation AsmLoc, ArrayRef< Token > AsmToks, SmallVectorImpl< unsigned > &TokOffsets, SmallString< 512 > &Asm)
Turn a sequence of our tokens back into a string that we can hand to the MC asm parser.
Definition: ParseStmtAsm.cpp:299
clang::Parser::ParseMSAsmIdentifier
ExprResult ParseMSAsmIdentifier(llvm::SmallVectorImpl< Token > &LineToks, unsigned &NumLineToksConsumed, bool IsUnevaluated)
Parse an identifier in an MS-style inline assembly block.
Definition: ParseStmtAsm.cpp:200
clang::Sema::FillInlineAsmIdentifierInfo
void FillInlineAsmIdentifierInfo(Expr *Res, llvm::InlineAsmIdentifierInfo &Info)
Definition: SemaStmtAsm.cpp:733
clang::StmtError
StmtResult StmtError()
Definition: Ownership.h:279
clang::SourceManager::getLineNumber
unsigned getLineNumber(FileID FID, unsigned FilePos, bool *Invalid=nullptr) const
Given a SourceLocation, return the spelling line number for the position indicated.
Definition: SourceManager.cpp:1347
clang::Sema::CorrectDelayedTyposInExpr
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
Definition: SemaExprCXX.cpp:8502
Parser.h