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