clang  5.0.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 "clang/AST/ASTContext.h"
16 #include "clang/Basic/Diagnostic.h"
17 #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  /*AllowDeductionGuide=*/false,
228  /*ObjectType=*/nullptr, TemplateKWLoc, Id);
229  // Perform the lookup.
230  Result = Actions.LookupInlineAsmIdentifier(SS, TemplateKWLoc, Id, Info,
231  IsUnevaluatedContext);
232  }
233  // While the next two tokens are 'period' 'identifier', repeatedly parse it as
234  // a field access. We have to avoid consuming assembler directives that look
235  // like '.' 'else'.
236  while (Result.isUsable() && Tok.is(tok::period)) {
237  Token IdTok = PP.LookAhead(0);
238  if (IdTok.isNot(tok::identifier))
239  break;
240  ConsumeToken(); // Consume the period.
241  IdentifierInfo *Id = Tok.getIdentifierInfo();
242  ConsumeToken(); // Consume the identifier.
243  Result = Actions.LookupInlineAsmVarDeclField(Result.get(), Id->getName(),
244  Info, Tok.getLocation());
245  }
246 
247  // Figure out how many tokens we are into LineToks.
248  unsigned LineIndex = 0;
249  if (Tok.is(EndOfStream)) {
250  LineIndex = LineToks.size() - 2;
251  } else {
252  while (LineToks[LineIndex].getLocation() != Tok.getLocation()) {
253  LineIndex++;
254  assert(LineIndex < LineToks.size() - 2); // we added two extra tokens
255  }
256  }
257 
258  // If we've run into the poison token we inserted before, or there
259  // was a parsing error, then claim the entire line.
260  if (Invalid || Tok.is(EndOfStream)) {
261  NumLineToksConsumed = LineToks.size() - 2;
262  } else {
263  // Otherwise, claim up to the start of the next token.
264  NumLineToksConsumed = LineIndex;
265  }
266 
267  // Finally, restore the old parsing state by consuming all the tokens we
268  // staged before, implicitly killing off the token-lexer we pushed.
269  for (unsigned i = 0, e = LineToks.size() - LineIndex - 2; i != e; ++i) {
270  ConsumeAnyToken();
271  }
272  assert(Tok.is(EndOfStream));
273  ConsumeToken();
274 
275  // Leave LineToks in its original state.
276  LineToks.pop_back();
277  LineToks.pop_back();
278 
279  return Result;
280 }
281 
282 /// Turn a sequence of our tokens back into a string that we can hand
283 /// to the MC asm parser.
285  ArrayRef<Token> AsmToks,
286  SmallVectorImpl<unsigned> &TokOffsets,
287  SmallString<512> &Asm) {
288  assert(!AsmToks.empty() && "Didn't expect an empty AsmToks!");
289 
290  // Is this the start of a new assembly statement?
291  bool isNewStatement = true;
292 
293  for (unsigned i = 0, e = AsmToks.size(); i < e; ++i) {
294  const Token &Tok = AsmToks[i];
295 
296  // Start each new statement with a newline and a tab.
297  if (!isNewStatement && (Tok.is(tok::kw_asm) || Tok.isAtStartOfLine())) {
298  Asm += "\n\t";
299  isNewStatement = true;
300  }
301 
302  // Preserve the existence of leading whitespace except at the
303  // start of a statement.
304  if (!isNewStatement && Tok.hasLeadingSpace())
305  Asm += ' ';
306 
307  // Remember the offset of this token.
308  TokOffsets.push_back(Asm.size());
309 
310  // Don't actually write '__asm' into the assembly stream.
311  if (Tok.is(tok::kw_asm)) {
312  // Complain about __asm at the end of the stream.
313  if (i + 1 == e) {
314  PP.Diag(AsmLoc, diag::err_asm_empty);
315  return true;
316  }
317 
318  continue;
319  }
320 
321  // Append the spelling of the token.
322  SmallString<32> SpellingBuffer;
323  bool SpellingInvalid = false;
324  Asm += PP.getSpelling(Tok, SpellingBuffer, &SpellingInvalid);
325  assert(!SpellingInvalid && "spelling was invalid after correct parse?");
326 
327  // We are no longer at the start of a statement.
328  isNewStatement = false;
329  }
330 
331  // Ensure that the buffer is null-terminated.
332  Asm.push_back('\0');
333  Asm.pop_back();
334 
335  assert(TokOffsets.size() == AsmToks.size());
336  return false;
337 }
338 
339 /// isTypeQualifier - Return true if the current token could be the
340 /// start of a type-qualifier-list.
341 static bool isTypeQualifier(const Token &Tok) {
342  switch (Tok.getKind()) {
343  default: return false;
344  // type-qualifier
345  case tok::kw_const:
346  case tok::kw_volatile:
347  case tok::kw_restrict:
348  case tok::kw___private:
349  case tok::kw___local:
350  case tok::kw___global:
351  case tok::kw___constant:
352  case tok::kw___generic:
353  case tok::kw___read_only:
354  case tok::kw___read_write:
355  case tok::kw___write_only:
356  return true;
357  }
358 }
359 
360 // Determine if this is a GCC-style asm statement.
361 static bool isGCCAsmStatement(const Token &TokAfterAsm) {
362  return TokAfterAsm.is(tok::l_paren) || TokAfterAsm.is(tok::kw_goto) ||
363  isTypeQualifier(TokAfterAsm);
364 }
365 
366 /// ParseMicrosoftAsmStatement. When -fms-extensions/-fasm-blocks is enabled,
367 /// this routine is called to collect the tokens for an MS asm statement.
368 ///
369 /// [MS] ms-asm-statement:
370 /// ms-asm-block
371 /// ms-asm-block ms-asm-statement
372 ///
373 /// [MS] ms-asm-block:
374 /// '__asm' ms-asm-line '\n'
375 /// '__asm' '{' ms-asm-instruction-block[opt] '}' ';'[opt]
376 ///
377 /// [MS] ms-asm-instruction-block
378 /// ms-asm-line
379 /// ms-asm-line '\n' ms-asm-instruction-block
380 ///
381 StmtResult Parser::ParseMicrosoftAsmStatement(SourceLocation AsmLoc) {
382  SourceManager &SrcMgr = PP.getSourceManager();
383  SourceLocation EndLoc = AsmLoc;
384  SmallVector<Token, 4> AsmToks;
385 
386  bool SingleLineMode = true;
387  unsigned BraceNesting = 0;
388  unsigned short savedBraceCount = BraceCount;
389  bool InAsmComment = false;
390  FileID FID;
391  unsigned LineNo = 0;
392  unsigned NumTokensRead = 0;
394  bool SkippedStartOfLine = false;
395 
396  if (Tok.is(tok::l_brace)) {
397  // Braced inline asm: consume the opening brace.
398  SingleLineMode = false;
399  BraceNesting = 1;
400  EndLoc = ConsumeBrace();
401  LBraceLocs.push_back(EndLoc);
402  ++NumTokensRead;
403  } else {
404  // Single-line inline asm; compute which line it is on.
405  std::pair<FileID, unsigned> ExpAsmLoc =
406  SrcMgr.getDecomposedExpansionLoc(EndLoc);
407  FID = ExpAsmLoc.first;
408  LineNo = SrcMgr.getLineNumber(FID, ExpAsmLoc.second);
409  LBraceLocs.push_back(SourceLocation());
410  }
411 
412  SourceLocation TokLoc = Tok.getLocation();
413  do {
414  // If we hit EOF, we're done, period.
415  if (isEofOrEom())
416  break;
417 
418  if (!InAsmComment && Tok.is(tok::l_brace)) {
419  // Consume the opening brace.
420  SkippedStartOfLine = Tok.isAtStartOfLine();
421  AsmToks.push_back(Tok);
422  EndLoc = ConsumeBrace();
423  BraceNesting++;
424  LBraceLocs.push_back(EndLoc);
425  TokLoc = Tok.getLocation();
426  ++NumTokensRead;
427  continue;
428  } else if (!InAsmComment && Tok.is(tok::semi)) {
429  // A semicolon in an asm is the start of a comment.
430  InAsmComment = true;
431  if (!SingleLineMode) {
432  // Compute which line the comment is on.
433  std::pair<FileID, unsigned> ExpSemiLoc =
434  SrcMgr.getDecomposedExpansionLoc(TokLoc);
435  FID = ExpSemiLoc.first;
436  LineNo = SrcMgr.getLineNumber(FID, ExpSemiLoc.second);
437  }
438  } else if (SingleLineMode || InAsmComment) {
439  // If end-of-line is significant, check whether this token is on a
440  // new line.
441  std::pair<FileID, unsigned> ExpLoc =
442  SrcMgr.getDecomposedExpansionLoc(TokLoc);
443  if (ExpLoc.first != FID ||
444  SrcMgr.getLineNumber(ExpLoc.first, ExpLoc.second) != LineNo) {
445  // If this is a single-line __asm, we're done, except if the next
446  // line is MS-style asm too, in which case we finish a comment
447  // if needed and then keep processing the next line as a single
448  // line __asm.
449  bool isAsm = Tok.is(tok::kw_asm);
450  if (SingleLineMode && (!isAsm || isGCCAsmStatement(NextToken())))
451  break;
452  // We're no longer in a comment.
453  InAsmComment = false;
454  if (isAsm) {
455  // If this is a new __asm {} block we want to process it separately
456  // from the single-line __asm statements
457  if (PP.LookAhead(0).is(tok::l_brace))
458  break;
459  LineNo = SrcMgr.getLineNumber(ExpLoc.first, ExpLoc.second);
460  SkippedStartOfLine = Tok.isAtStartOfLine();
461  } else if (Tok.is(tok::semi)) {
462  // A multi-line asm-statement, where next line is a comment
463  InAsmComment = true;
464  FID = ExpLoc.first;
465  LineNo = SrcMgr.getLineNumber(FID, ExpLoc.second);
466  }
467  } else if (!InAsmComment && Tok.is(tok::r_brace)) {
468  // In MSVC mode, braces only participate in brace matching and
469  // separating the asm statements. This is an intentional
470  // departure from the Apple gcc behavior.
471  if (!BraceNesting)
472  break;
473  }
474  }
475  if (!InAsmComment && BraceNesting && Tok.is(tok::r_brace) &&
476  BraceCount == (savedBraceCount + BraceNesting)) {
477  // Consume the closing brace.
478  SkippedStartOfLine = Tok.isAtStartOfLine();
479  // Don't want to add the closing brace of the whole asm block
480  if (SingleLineMode || BraceNesting > 1) {
482  AsmToks.push_back(Tok);
483  }
484  EndLoc = ConsumeBrace();
485  BraceNesting--;
486  // Finish if all of the opened braces in the inline asm section were
487  // consumed.
488  if (BraceNesting == 0 && !SingleLineMode)
489  break;
490  else {
491  LBraceLocs.pop_back();
492  TokLoc = Tok.getLocation();
493  ++NumTokensRead;
494  continue;
495  }
496  }
497 
498  // Consume the next token; make sure we don't modify the brace count etc.
499  // if we are in a comment.
500  EndLoc = TokLoc;
501  if (InAsmComment)
502  PP.Lex(Tok);
503  else {
504  // Set the token as the start of line if we skipped the original start
505  // of line token in case it was a nested brace.
506  if (SkippedStartOfLine)
508  AsmToks.push_back(Tok);
509  ConsumeAnyToken();
510  }
511  TokLoc = Tok.getLocation();
512  ++NumTokensRead;
513  SkippedStartOfLine = false;
514  } while (1);
515 
516  if (BraceNesting && BraceCount != savedBraceCount) {
517  // __asm without closing brace (this can happen at EOF).
518  for (unsigned i = 0; i < BraceNesting; ++i) {
519  Diag(Tok, diag::err_expected) << tok::r_brace;
520  Diag(LBraceLocs.back(), diag::note_matching) << tok::l_brace;
521  LBraceLocs.pop_back();
522  }
523  return StmtError();
524  } else if (NumTokensRead == 0) {
525  // Empty __asm.
526  Diag(Tok, diag::err_expected) << tok::l_brace;
527  return StmtError();
528  }
529 
530  // Okay, prepare to use MC to parse the assembly.
531  SmallVector<StringRef, 4> ConstraintRefs;
533  SmallVector<StringRef, 4> ClobberRefs;
534 
535  // We need an actual supported target.
536  const llvm::Triple &TheTriple = Actions.Context.getTargetInfo().getTriple();
537  llvm::Triple::ArchType ArchTy = TheTriple.getArch();
538  const std::string &TT = TheTriple.getTriple();
539  const llvm::Target *TheTarget = nullptr;
540  bool UnsupportedArch =
541  (ArchTy != llvm::Triple::x86 && ArchTy != llvm::Triple::x86_64);
542  if (UnsupportedArch) {
543  Diag(AsmLoc, diag::err_msasm_unsupported_arch) << TheTriple.getArchName();
544  } else {
545  std::string Error;
546  TheTarget = llvm::TargetRegistry::lookupTarget(TT, Error);
547  if (!TheTarget)
548  Diag(AsmLoc, diag::err_msasm_unable_to_create_target) << Error;
549  }
550 
551  assert(!LBraceLocs.empty() && "Should have at least one location here");
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 Actions.ActOnMSAsmStmt(AsmLoc, LBraceLocs[0], AsmToks, StringRef(),
557  /*NumOutputs*/ 0, /*NumInputs*/ 0,
558  ConstraintRefs, ClobberRefs, Exprs, EndLoc);
559  }
560 
561  // Expand the tokens into a string buffer.
562  SmallString<512> AsmString;
563  SmallVector<unsigned, 8> TokOffsets;
564  if (buildMSAsmString(PP, AsmLoc, AsmToks, TokOffsets, AsmString))
565  return StmtError();
566 
568  std::string FeaturesStr =
569  llvm::join(TO.Features.begin(), TO.Features.end(), ",");
570 
571  std::unique_ptr<llvm::MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TT));
572  std::unique_ptr<llvm::MCAsmInfo> MAI(TheTarget->createMCAsmInfo(*MRI, TT));
573  // Get the instruction descriptor.
574  std::unique_ptr<llvm::MCInstrInfo> MII(TheTarget->createMCInstrInfo());
575  std::unique_ptr<llvm::MCObjectFileInfo> MOFI(new llvm::MCObjectFileInfo());
576  std::unique_ptr<llvm::MCSubtargetInfo> STI(
577  TheTarget->createMCSubtargetInfo(TT, TO.CPU, FeaturesStr));
578 
579  llvm::SourceMgr TempSrcMgr;
580  llvm::MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &TempSrcMgr);
581  MOFI->InitMCObjectFileInfo(TheTriple, /*PIC*/ false, llvm::CodeModel::Default,
582  Ctx);
583  std::unique_ptr<llvm::MemoryBuffer> Buffer =
584  llvm::MemoryBuffer::getMemBuffer(AsmString, "<MS inline asm>");
585 
586  // Tell SrcMgr about this buffer, which is what the parser will pick up.
587  TempSrcMgr.AddNewSourceBuffer(std::move(Buffer), llvm::SMLoc());
588 
589  std::unique_ptr<llvm::MCStreamer> Str(createNullStreamer(Ctx));
590  std::unique_ptr<llvm::MCAsmParser> Parser(
591  createMCAsmParser(TempSrcMgr, Ctx, *Str.get(), *MAI));
592 
593  // FIXME: init MCOptions from sanitizer flags here.
594  llvm::MCTargetOptions MCOptions;
595  std::unique_ptr<llvm::MCTargetAsmParser> TargetParser(
596  TheTarget->createMCAsmParser(*STI, *Parser, *MII, MCOptions));
597 
598  std::unique_ptr<llvm::MCInstPrinter> IP(
599  TheTarget->createMCInstPrinter(llvm::Triple(TT), 1, *MAI, *MII, *MRI));
600 
601  // Change to the Intel dialect.
602  Parser->setAssemblerDialect(1);
603  Parser->setTargetParser(*TargetParser.get());
604  Parser->setParsingInlineAsm(true);
605  TargetParser->setParsingInlineAsm(true);
606 
607  ClangAsmParserCallback Callback(*this, AsmLoc, AsmString, AsmToks,
608  TokOffsets);
609  TargetParser->setSemaCallback(&Callback);
610  TempSrcMgr.setDiagHandler(ClangAsmParserCallback::DiagHandlerCallback,
611  &Callback);
612 
613  unsigned NumOutputs;
614  unsigned NumInputs;
615  std::string AsmStringIR;
617  SmallVector<std::string, 4> Constraints;
619  if (Parser->parseMSInlineAsm(AsmLoc.getPtrEncoding(), AsmStringIR, NumOutputs,
620  NumInputs, OpExprs, Constraints, Clobbers,
621  MII.get(), IP.get(), Callback))
622  return StmtError();
623 
624  // Filter out "fpsw" and "mxcsr". They aren't valid GCC asm clobber
625  // constraints. Clang always adds fpsr to the clobber list anyway.
626  llvm::erase_if(Clobbers, [](const std::string &C) {
627  return C == "fpsw" || C == "mxcsr";
628  });
629 
630  // Build the vector of clobber StringRefs.
631  ClobberRefs.insert(ClobberRefs.end(), Clobbers.begin(), Clobbers.end());
632 
633  // Recast the void pointers and build the vector of constraint StringRefs.
634  unsigned NumExprs = NumOutputs + NumInputs;
635  ConstraintRefs.resize(NumExprs);
636  Exprs.resize(NumExprs);
637  for (unsigned i = 0, e = NumExprs; i != e; ++i) {
638  Expr *OpExpr = static_cast<Expr *>(OpExprs[i].first);
639  if (!OpExpr)
640  return StmtError();
641 
642  // Need address of variable.
643  if (OpExprs[i].second)
644  OpExpr =
645  Actions.BuildUnaryOp(getCurScope(), AsmLoc, UO_AddrOf, OpExpr).get();
646 
647  ConstraintRefs[i] = StringRef(Constraints[i]);
648  Exprs[i] = OpExpr;
649  }
650 
651  // FIXME: We should be passing source locations for better diagnostics.
652  return Actions.ActOnMSAsmStmt(AsmLoc, LBraceLocs[0], AsmToks, AsmStringIR,
653  NumOutputs, NumInputs, ConstraintRefs,
654  ClobberRefs, Exprs, EndLoc);
655 }
656 
657 /// ParseAsmStatement - Parse a GNU extended asm statement.
658 /// asm-statement:
659 /// gnu-asm-statement
660 /// ms-asm-statement
661 ///
662 /// [GNU] gnu-asm-statement:
663 /// 'asm' type-qualifier[opt] '(' asm-argument ')' ';'
664 ///
665 /// [GNU] asm-argument:
666 /// asm-string-literal
667 /// asm-string-literal ':' asm-operands[opt]
668 /// asm-string-literal ':' asm-operands[opt] ':' asm-operands[opt]
669 /// asm-string-literal ':' asm-operands[opt] ':' asm-operands[opt]
670 /// ':' asm-clobbers
671 ///
672 /// [GNU] asm-clobbers:
673 /// asm-string-literal
674 /// asm-clobbers ',' asm-string-literal
675 ///
676 StmtResult Parser::ParseAsmStatement(bool &msAsm) {
677  assert(Tok.is(tok::kw_asm) && "Not an asm stmt");
678  SourceLocation AsmLoc = ConsumeToken();
679 
680  if (getLangOpts().AsmBlocks && !isGCCAsmStatement(Tok)) {
681  msAsm = true;
682  return ParseMicrosoftAsmStatement(AsmLoc);
683  }
684 
685  DeclSpec DS(AttrFactory);
686  SourceLocation Loc = Tok.getLocation();
687  ParseTypeQualifierListOpt(DS, AR_VendorAttributesParsed);
688 
689  // GNU asms accept, but warn, about type-qualifiers other than volatile.
690  if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
691  Diag(Loc, diag::warn_asm_qualifier_ignored) << "const";
692  if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
693  Diag(Loc, diag::warn_asm_qualifier_ignored) << "restrict";
694  // FIXME: Once GCC supports _Atomic, check whether it permits it here.
695  if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
696  Diag(Loc, diag::warn_asm_qualifier_ignored) << "_Atomic";
697 
698  // Remember if this was a volatile asm.
699  bool isVolatile = DS.getTypeQualifiers() & DeclSpec::TQ_volatile;
700 
701  // TODO: support "asm goto" constructs (PR#9295).
702  if (Tok.is(tok::kw_goto)) {
703  Diag(Tok, diag::err_asm_goto_not_supported_yet);
704  SkipUntil(tok::r_paren, StopAtSemi);
705  return StmtError();
706  }
707 
708  if (Tok.isNot(tok::l_paren)) {
709  Diag(Tok, diag::err_expected_lparen_after) << "asm";
710  SkipUntil(tok::r_paren, StopAtSemi);
711  return StmtError();
712  }
713  BalancedDelimiterTracker T(*this, tok::l_paren);
714  T.consumeOpen();
715 
716  ExprResult AsmString(ParseAsmStringLiteral());
717 
718  // Check if GNU-style InlineAsm is disabled.
719  // Error on anything other than empty string.
720  if (!(getLangOpts().GNUAsm || AsmString.isInvalid())) {
721  const auto *SL = cast<StringLiteral>(AsmString.get());
722  if (!SL->getString().trim().empty())
723  Diag(Loc, diag::err_gnu_inline_asm_disabled);
724  }
725 
726  if (AsmString.isInvalid()) {
727  // Consume up to and including the closing paren.
728  T.skipToEnd();
729  return StmtError();
730  }
731 
733  ExprVector Constraints;
734  ExprVector Exprs;
735  ExprVector Clobbers;
736 
737  if (Tok.is(tok::r_paren)) {
738  // We have a simple asm expression like 'asm("foo")'.
739  T.consumeClose();
740  return Actions.ActOnGCCAsmStmt(AsmLoc, /*isSimple*/ true, isVolatile,
741  /*NumOutputs*/ 0, /*NumInputs*/ 0, nullptr,
742  Constraints, Exprs, AsmString.get(),
743  Clobbers, T.getCloseLocation());
744  }
745 
746  // Parse Outputs, if present.
747  bool AteExtraColon = false;
748  if (Tok.is(tok::colon) || Tok.is(tok::coloncolon)) {
749  // In C++ mode, parse "::" like ": :".
750  AteExtraColon = Tok.is(tok::coloncolon);
751  ConsumeToken();
752 
753  if (!AteExtraColon && ParseAsmOperandsOpt(Names, Constraints, Exprs))
754  return StmtError();
755  }
756 
757  unsigned NumOutputs = Names.size();
758 
759  // Parse Inputs, if present.
760  if (AteExtraColon || Tok.is(tok::colon) || Tok.is(tok::coloncolon)) {
761  // In C++ mode, parse "::" like ": :".
762  if (AteExtraColon)
763  AteExtraColon = false;
764  else {
765  AteExtraColon = Tok.is(tok::coloncolon);
766  ConsumeToken();
767  }
768 
769  if (!AteExtraColon && ParseAsmOperandsOpt(Names, Constraints, Exprs))
770  return StmtError();
771  }
772 
773  assert(Names.size() == Constraints.size() &&
774  Constraints.size() == Exprs.size() && "Input operand size mismatch!");
775 
776  unsigned NumInputs = Names.size() - NumOutputs;
777 
778  // Parse the clobbers, if present.
779  if (AteExtraColon || Tok.is(tok::colon)) {
780  if (!AteExtraColon)
781  ConsumeToken();
782 
783  // Parse the asm-string list for clobbers if present.
784  if (Tok.isNot(tok::r_paren)) {
785  while (1) {
786  ExprResult Clobber(ParseAsmStringLiteral());
787 
788  if (Clobber.isInvalid())
789  break;
790 
791  Clobbers.push_back(Clobber.get());
792 
793  if (!TryConsumeToken(tok::comma))
794  break;
795  }
796  }
797  }
798 
799  T.consumeClose();
800  return Actions.ActOnGCCAsmStmt(
801  AsmLoc, false, isVolatile, NumOutputs, NumInputs, Names.data(),
802  Constraints, Exprs, AsmString.get(), Clobbers, T.getCloseLocation());
803 }
804 
805 /// ParseAsmOperands - Parse the asm-operands production as used by
806 /// asm-statement, assuming the leading ':' token was eaten.
807 ///
808 /// [GNU] asm-operands:
809 /// asm-operand
810 /// asm-operands ',' asm-operand
811 ///
812 /// [GNU] asm-operand:
813 /// asm-string-literal '(' expression ')'
814 /// '[' identifier ']' asm-string-literal '(' expression ')'
815 ///
816 //
817 // FIXME: Avoid unnecessary std::string trashing.
818 bool Parser::ParseAsmOperandsOpt(SmallVectorImpl<IdentifierInfo *> &Names,
819  SmallVectorImpl<Expr *> &Constraints,
820  SmallVectorImpl<Expr *> &Exprs) {
821  // 'asm-operands' isn't present?
822  if (!isTokenStringLiteral() && Tok.isNot(tok::l_square))
823  return false;
824 
825  while (1) {
826  // Read the [id] if present.
827  if (Tok.is(tok::l_square)) {
828  BalancedDelimiterTracker T(*this, tok::l_square);
829  T.consumeOpen();
830 
831  if (Tok.isNot(tok::identifier)) {
832  Diag(Tok, diag::err_expected) << tok::identifier;
833  SkipUntil(tok::r_paren, StopAtSemi);
834  return true;
835  }
836 
837  IdentifierInfo *II = Tok.getIdentifierInfo();
838  ConsumeToken();
839 
840  Names.push_back(II);
841  T.consumeClose();
842  } else
843  Names.push_back(nullptr);
844 
845  ExprResult Constraint(ParseAsmStringLiteral());
846  if (Constraint.isInvalid()) {
847  SkipUntil(tok::r_paren, StopAtSemi);
848  return true;
849  }
850  Constraints.push_back(Constraint.get());
851 
852  if (Tok.isNot(tok::l_paren)) {
853  Diag(Tok, diag::err_expected_lparen_after) << "asm operand";
854  SkipUntil(tok::r_paren, StopAtSemi);
855  return true;
856  }
857 
858  // Read the parenthesized expression.
859  BalancedDelimiterTracker T(*this, tok::l_paren);
860  T.consumeOpen();
862  T.consumeClose();
863  if (Res.isInvalid()) {
864  SkipUntil(tok::r_paren, StopAtSemi);
865  return true;
866  }
867  Exprs.push_back(Res.get());
868  // Eat the comma and continue parsing if it exists.
869  if (!TryConsumeToken(tok::comma))
870  return false;
871  }
872 }
bool isAtStartOfLine() const
isAtStartOfLine - Return true if this token is at the start of a line.
Definition: Token.h:266
SourceManager & getSourceManager() const
Definition: Preprocessor.h:729
Defines the clang::ASTContext interface.
ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)
Simple precedence-based parser for binary/ternary operators.
Definition: ParseExpr.cpp:119
bool isInvalid() const
Definition: Ownership.h:159
std::pair< FileID, unsigned > getDecomposedExpansionLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
StringRef getMSAsmLabel() const
Definition: Decl.h:452
const LangOptions & getLangOpts() const
Definition: Parser.h:267
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:270
PtrTy get() const
Definition: Ownership.h:163
std::unique_ptr< llvm::MemoryBuffer > Buffer
void setFlag(TokenFlags Flag)
Set the specified flag.
Definition: Token.h:234
Parser - This implements a parser for the C family of languages.
Definition: Parser.h:57
Options for controlling the target.
Definition: TargetOptions.h:26
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input)
Definition: SemaExpr.cpp:12019
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: Parser.h:934
static bool isGCCAsmStatement(const Token &TokAfterAsm)
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
Definition: Parser.h:602
bool TryConsumeToken(tok::TokenKind Expected)
Definition: Parser.h:320
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
bool ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext, bool AllowDestructorName, bool AllowConstructorName, bool AllowDeductionGuide, ParsedType ObjectType, SourceLocation &TemplateKWLoc, UnqualifiedId &Result)
Parse a C++ unqualified-id (or a C identifier), which describes the name of an entity.
void setKind(tok::TokenKind K)
Definition: Token.h:91
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:899
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:643
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
uint32_t Offset
Definition: CacheTokens.cpp:43
StmtResult StmtError()
Definition: Ownership.h:269
Defines the Diagnostic-related interfaces.
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
tok::TokenKind getKind() const
Definition: Token.h:90
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member, llvm::InlineAsmIdentifierInfo &Info, SourceLocation AsmLoc)
ASTContext * Context
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.
std::string Label
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:124
bool isNot(tok::TokenKind K) const
Definition: Token.h:96
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: Parser.h:914
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:145
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)
Definition: Parser.cpp:50
LabelDecl - Represents the declaration of a label.
Definition: Decl.h:414
Scope * getCurScope() const
Definition: Parser.h:274
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:95
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.
Definition: TargetInfo.h:792
SourceMgr(SourceMgr)
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Definition: Parser.cpp:72
TargetOptions & getTargetOpts() const
Retrieve the target options.
Definition: TargetInfo.h:121
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:253
bool isUsable() const
Definition: Ownership.h:160
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
SourceLocation ConsumeToken()
ConsumeToken - Consume the current 'peek token' and lex the next one.
Definition: Parser.h:312
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:305
void clearFlag(TokenFlags Flag)
Unset the specified flag.
Definition: Token.h:244
This class handles loading and caching of source files into memory.
void startToken()
Reset all flags to cleared.
Definition: Token.h:169
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:98
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:177