clang 19.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
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"
34using namespace clang;
35
36namespace {
37class 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
48public:
49 ClangAsmParserCallback(Parser &P, SourceLocation Loc, StringRef AsmString,
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
74private:
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
86void ClangAsmParserCallback::LookupInlineAsmIdentifier(
87 StringRef &LineBuf, llvm::InlineAsmIdentifierInfo &Info,
88 bool IsUnevaluatedContext) {
89 // Collect the desired tokens.
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
127StringRef ClangAsmParserCallback::LookupInlineAsmLabel(StringRef Identifier,
128 llvm::SourceMgr &LSM,
129 llvm::SMLoc Location,
130 bool Create) {
131 SourceLocation Loc = translateLocation(LSM, Location);
134 return Label->getMSAsmLabel();
135}
136
137void 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
167ClangAsmParserCallback::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
193void 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.
220
221 // Parse an optional scope-specifier if we're in C++.
222 CXXScopeSpec SS;
224 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
225 /*ObjectHasErrors=*/false,
226 /*EnteringContext=*/false);
227
228 // Require an identifier here.
229 SourceLocation TemplateKWLoc;
231 bool Invalid = true;
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) {
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,
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.
355bool Parser::isGCCAsmStatement(const Token &TokAfterAsm) const {
356 return TokAfterAsm.is(tok::l_paren) || isGNUAsmQualifier(TokAfterAsm);
357}
358
359bool 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///
378StmtResult 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);
507 }
508 TokLoc = Tok.getLocation();
509 ++NumTokensRead;
510 SkippedStartOfLine = false;
511 } while (true);
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 {
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 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
683bool Parser::parseGNUAsmQualifierListOpt(GNUAsmQualifiers &AQ) {
684 while (true) {
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///
721StmtResult 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
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 (true) {
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 }
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.
884bool Parser::ParseAsmOperandsOpt(SmallVectorImpl<IdentifierInfo *> &Names,
885 SmallVectorImpl<Expr *> &Constraints,
887 // 'asm-operands' isn't present?
888 if (!isTokenStringLiteral() && Tok.isNot(tok::l_square))
889 return false;
890
891 while (true) {
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
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
940const 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
950Parser::GNUAsmQualifiers::AQ
951Parser::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}
959bool Parser::GNUAsmQualifiers::setAsmQualifier(AQ Qualifier) {
960 bool IsDuplicate = Qualifiers & Qualifier;
962 return IsDuplicate;
963}
Defines the clang::ASTContext interface.
StringRef P
Defines the Diagnostic-related interfaces.
StringRef Identifier
Definition: Format.cpp:2984
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.
uint32_t Id
Definition: SemaARM.cpp:1091
SourceLocation Loc
Definition: SemaObjC.cpp:758
std::string Label
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:760
PtrTy get() const
Definition: Ownership.h:170
bool isInvalid() const
Definition: Ownership.h:166
RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ....
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:74
This represents one expression.
Definition: Expr.h:110
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
One of these records is kept for each identifier that is lexed.
Represents the declaration of a label.
Definition: Decl.h:499
Parser - This implements a parser for the C family of languages.
Definition: Parser.h:58
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Definition: Parser.cpp:81
SourceLocation ConsumeToken()
ConsumeToken - Consume the current 'peek token' and lex the next one.
Definition: Parser.h:548
Sema & getActions() const
Definition: Parser.h:498
ExprResult ParseMSAsmIdentifier(llvm::SmallVectorImpl< Token > &LineToks, unsigned &NumLineToksConsumed, bool IsUnevaluated)
Parse an identifier in an MS-style inline assembly block.
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.
SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok=false)
ConsumeAnyToken - Dispatch to the right Consume* method based on the current token type.
Definition: Parser.h:576
bool TryConsumeToken(tok::TokenKind Expected)
Definition: Parser.h:556
Scope * getCurScope() const
Definition: Parser.h:502
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:1294
const LangOptions & getLangOpts() const
Definition: Parser.h:495
ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)
Simple precedence-based parser for binary/ternary operators.
Definition: ParseExpr.cpp:132
@ StopAtSemi
Stop skipping at semicolon.
Definition: Parser.h:1273
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
Definition: Parser.h:872
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:128
void Lex(Token &Result)
Lex the next token for this preprocessor.
const Token & LookAhead(unsigned N)
Peeks ahead N tokens and returns that token without consuming any tokens.
SourceManager & getSourceManager() const
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 ...
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
The collection of all-type qualifiers we support.
Definition: Type.h:318
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)
ExprResult LookupInlineAsmIdentifier(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool IsUnevaluatedContext)
ASTContext & Context
Definition: Sema.h:873
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input, bool IsAfterAmp=false)
Definition: SemaExpr.cpp:15683
ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, LabelDecl *TheDecl)
ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
Definition: SemaExpr.cpp:15735
void FillInlineAsmIdentifierInfo(Expr *Res, llvm::InlineAsmIdentifierInfo &Info)
bool LookupInlineAsmField(StringRef Base, StringRef Member, unsigned &Offset, SourceLocation AsmLoc)
LabelDecl * LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc, SourceLocation GnuLabelLoc=SourceLocation())
LookupOrCreateLabel - Do a name lookup of a label with the specified name.
ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member, SourceLocation AsmLoc)
LabelDecl * GetOrCreateMSAsmLabel(StringRef ExternalLabelName, SourceLocation Location, bool AlwaysCreate)
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...
StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, bool IsVolatile, unsigned NumOutputs, unsigned NumInputs, IdentifierInfo **Names, MultiExprArg Constraints, MultiExprArg Exprs, Expr *AsmString, MultiExprArg Clobbers, unsigned NumLabels, SourceLocation RParenLoc)
Encodes a location in the source.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
This class handles loading and caching of source files into memory.
unsigned getLineNumber(FileID FID, unsigned FilePos, bool *Invalid=nullptr) const
Given a SourceLocation, return the spelling line number for the position indicated.
std::pair< FileID, unsigned > getDecomposedExpansionLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
TargetOptions & getTargetOpts() const
Retrieve the target options.
Definition: TargetInfo.h:312
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:1256
Options for controlling the target.
Definition: TargetOptions.h:26
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
std::string CPU
If given, the name of the target CPU to generate code for.
Definition: TargetOptions.h:36
Token - This structure provides full information about a lexed token.
Definition: Token.h:36
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:187
void clearFlag(TokenFlags Flag)
Unset the specified flag.
Definition: Token.h:254
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file.
Definition: Token.h:132
void setKind(tok::TokenKind K)
Definition: Token.h:95
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:99
tok::TokenKind getKind() const
Definition: Token.h:94
bool isAtStartOfLine() const
isAtStartOfLine - Return true if this token is at the start of a line.
Definition: Token.h:276
@ LeadingSpace
Definition: Token.h:77
@ StartOfLine
Definition: Token.h:75
bool hasLeadingSpace() const
Return true if this token has whitespace before it.
Definition: Token.h:280
bool isNot(tok::TokenKind K) const
Definition: Token.h:100
void startToken()
Reset all flags to cleared.
Definition: Token.h:177
void setFlag(TokenFlags Flag)
Set the specified flag.
Definition: Token.h:244
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:1025
Defines the clang::TargetInfo interface.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
The JSON file list parser is used to communicate input to InstallAPI.
@ Create
'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
@ CPlusPlus
Definition: LangStandard.h:55
@ Asm
Assembly: we accept this only so that we can preprocess it.
StmtResult StmtError()
Definition: Ownership.h:265
@ Result
The result type of a method or function.
const FunctionProtoType * T