Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/ParseStmtAsm_8cpp_source.html below:

clang: lib/Parse/ParseStmtAsm.cpp Source File

;

ClangAsmParserCallback :

llvm::MCAsmParserSemaCallback {

: TheParser(

), AsmLoc(

), AsmString(AsmString), AsmToks(Toks),

AsmTokOffsets(Offsets) {

assert(AsmToks.size() == AsmTokOffsets.size());

LookupInlineAsmIdentifier(StringRef &LineBuf,

llvm::InlineAsmIdentifierInfo &Info,

IsUnevaluatedContext)

;

StringRef LookupInlineAsmLabel(StringRef

, llvm::SourceMgr &LSM,

LookupInlineAsmField(StringRef

, StringRef

,

&Offset)

{

DiagHandlerCallback(

llvm::SMDiagnostic &

,

*Context) {

((ClangAsmParserCallback *)Context)->handleDiagnostic(

);

*&FirstOrigToken)

;

handleDiagnostic(

llvm::SMDiagnostic &

);

ClangAsmParserCallback::LookupInlineAsmIdentifier(

StringRef &LineBuf, llvm::InlineAsmIdentifierInfo &Info,

IsUnevaluatedContext) {

*FirstOrigToken =

;

findTokensForString(LineBuf, LineToks, FirstOrigToken);

NumConsumedToks;

IsUnevaluatedContext);

(NumConsumedToks == 0 || NumConsumedToks == LineToks.size()) {

assert(FirstOrigToken &&

);

assert(FirstOrigToken[NumConsumedToks].getLocation() ==

LineToks[NumConsumedToks].getLocation());

FirstIndex = FirstOrigToken - AsmToks.begin();

LastIndex = FirstIndex + NumConsumedToks - 1;

TotalOffset =

(AsmTokOffsets[LastIndex] + AsmToks[LastIndex].getLength() -

AsmTokOffsets[FirstIndex]);

LineBuf = LineBuf.substr(0, TotalOffset);

(!Result.isUsable())

StringRef ClangAsmParserCallback::LookupInlineAsmLabel(StringRef

,

llvm::SourceMgr &LSM,

llvm::SMLoc Location,

->getMSAsmLabel();

ClangAsmParserCallback::findTokensForString(

*&FirstOrigToken)

{

assert(!std::less<const char *>()(Str.begin(), AsmString.begin()) &&

!std::less<const char *>()(AsmString.end(), Str.end()));

FirstCharOffset = Str.begin() - AsmString.begin();

*FirstTokOffset =

llvm::lower_bound(AsmTokOffsets, FirstCharOffset);

assert(*FirstTokOffset == FirstCharOffset);

FirstTokIndex = FirstTokOffset - AsmTokOffsets.begin();

FirstOrigToken = &AsmToks[FirstTokIndex];

LastCharOffset = Str.end() - AsmString.begin();

(

i = FirstTokIndex, e = AsmTokOffsets.size(); i != e; ++i) {

(AsmTokOffsets[i] >= LastCharOffset)

TempToks.push_back(AsmToks[i]);

ClangAsmParserCallback::translateLocation(

llvm::SourceMgr &LSM,

llvm::MemoryBuffer *LBuf =

LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(SMLoc));

Offset = SMLoc.getPointer() - LBuf->getBufferStart();

*TokOffsetPtr = llvm::lower_bound(AsmTokOffsets, Offset);

TokIndex = TokOffsetPtr - AsmTokOffsets.begin();

TokOffset = *TokOffsetPtr;

(TokIndex < AsmToks.size()) {

&Tok = AsmToks[TokIndex];

ClangAsmParserCallback::handleDiagnostic(

llvm::SMDiagnostic &

) {

llvm::SourceMgr &LSM = *

.getSourceMgr();

TheParser.

(

, diag::err_inline_ms_asm_parsing) <<

.getMessage();

&NumLineToksConsumed,

IsUnevaluatedContext) {

EndOfStreamTok;

EndOfStreamTok.

(EndOfStream);

LineToks.push_back(EndOfStreamTok);

LineToks.push_back(Tok);

PP.EnterTokenStream(LineToks,

,

ParseOptionalCXXScopeSpecifier(SS,

,

Invalid =

;

(Tok.

(tok::kw_this)) {

, &TemplateKWLoc,

);

IsUnevaluatedContext);

(

.isUsable() && Tok.

(tok::period)) {

(IdTok.

(tok::identifier))

LineIndex = 0;

(Tok.

(EndOfStream)) {

LineIndex = LineToks.size() - 2;

(LineToks[LineIndex].getLocation() != Tok.

()) {

assert(LineIndex < LineToks.size() - 2);

(Invalid || Tok.

(EndOfStream)) {

NumLineToksConsumed = LineToks.size() - 2;

NumLineToksConsumed = LineIndex;

(

i = 0, e = LineToks.size() - LineIndex - 2; i != e; ++i) {

assert(Tok.

(EndOfStream));

assert(!AsmToks.empty() &&

);

isNewStatement =

;

(

i = 0, e = AsmToks.size(); i < e; ++i) {

&Tok = AsmToks[i];

isNewStatement =

;

TokOffsets.push_back(

.size());

(Tok.

(tok::kw_asm)) {

PP.

(AsmLoc, diag::err_asm_empty);

SpellingInvalid =

;

assert(!SpellingInvalid &&

);

isNewStatement =

;

.push_back(

);

assert(TokOffsets.size() == AsmToks.size());

Parser::isGCCAsmStatement(

&TokAfterAsm)

{

TokAfterAsm.

(tok::l_paren) || isGNUAsmQualifier(TokAfterAsm);

Parser::isGNUAsmQualifier(

&TokAfterAsm)

{

getGNUAsmQualifier(TokAfterAsm) != GNUAsmQualifiers::AQ_unspecified;

SingleLineMode =

;

BraceNesting = 0;

savedBraceCount = BraceCount;

InAsmComment =

;

NumTokensRead = 0;

SkippedStartOfLine =

;

(Tok.

(tok::l_brace)) {

SingleLineMode =

;

EndLoc = ConsumeBrace();

LBraceLocs.push_back(EndLoc);

std::pair<FileID, unsigned> ExpAsmLoc =

FID = ExpAsmLoc.first;

(!InAsmComment && Tok.

(tok::l_brace)) {

AsmToks.push_back(Tok);

EndLoc = ConsumeBrace();

LBraceLocs.push_back(EndLoc);

}

(!InAsmComment && Tok.

(tok::semi)) {

InAsmComment =

;

(!SingleLineMode) {

std::pair<FileID, unsigned> ExpSemiLoc =

FID = ExpSemiLoc.first;

}

(SingleLineMode || InAsmComment) {

std::pair<FileID, unsigned> ExpLoc =

(ExpLoc.first != FID ||

SrcMgr.

(ExpLoc.first, ExpLoc.second) != LineNo) {

isAsm = Tok.

(tok::kw_asm);

(SingleLineMode && (!isAsm || isGCCAsmStatement(

())))

InAsmComment =

;

LineNo = SrcMgr.

(ExpLoc.first, ExpLoc.second);

}

(Tok.

(tok::semi)) {

InAsmComment =

;

}

(!InAsmComment && Tok.

(tok::r_brace)) {

(!InAsmComment && BraceNesting && Tok.

(tok::r_brace) &&

BraceCount == (savedBraceCount + BraceNesting)) {

(SingleLineMode || BraceNesting > 1) {

AsmToks.push_back(Tok);

EndLoc = ConsumeBrace();

(BraceNesting == 0 && !SingleLineMode)

LBraceLocs.pop_back();

(SkippedStartOfLine)

AsmToks.push_back(Tok);

SkippedStartOfLine =

;

(BraceNesting && BraceCount != savedBraceCount) {

(

i = 0; i < BraceNesting; ++i) {

(Tok, diag::err_expected) << tok::r_brace;

(LBraceLocs.back(), diag::note_matching) << tok::l_brace;

LBraceLocs.pop_back();

}

(NumTokensRead == 0) {

(Tok, diag::err_expected) << tok::l_brace;

std::string &TT = TheTriple.getTriple();

llvm::Target *TheTarget =

;

(!TheTriple.isX86()) {

(AsmLoc, diag::err_msasm_unsupported_arch) << TheTriple.getArchName();

TheTarget = llvm::TargetRegistry::lookupTarget(TT, Error);

(AsmLoc, diag::err_msasm_unable_to_create_target) <<

;

assert(!LBraceLocs.empty() &&

);

EmptyStmt = [&] {

Actions.

(AsmLoc, LBraceLocs[0], AsmToks, AsmString,

ConstraintRefs, ClobberRefs, Exprs, EndLoc);

(!TheTarget || AsmToks.empty()) {

std::string FeaturesStr =

std::unique_ptr<llvm::MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TT));

(AsmLoc, diag::err_msasm_unable_to_create_target)

<<

;

llvm::MCTargetOptions MCOptions;

std::unique_ptr<llvm::MCAsmInfo> MAI(

TheTarget->createMCAsmInfo(*MRI, TT, MCOptions));

std::unique_ptr<llvm::MCInstrInfo> MII(TheTarget->createMCInstrInfo());

std::unique_ptr<llvm::MCSubtargetInfo> STI(

TheTarget->createMCSubtargetInfo(TT, TO.

, FeaturesStr));

(!MAI || !MII || !STI) {

(AsmLoc, diag::err_msasm_unable_to_create_target)

<<

;

llvm::SourceMgr TempSrcMgr;

llvm::MCContext Ctx(TheTriple, MAI.get(), MRI.get(), STI.get(), &TempSrcMgr);

std::unique_ptr<llvm::MCObjectFileInfo> MOFI(

TheTarget->createMCObjectFileInfo(Ctx,

));

Ctx.setObjectFileInfo(MOFI.get());

std::unique_ptr<llvm::MemoryBuffer> Buffer =

llvm::MemoryBuffer::getMemBuffer(AsmString,

);

TempSrcMgr.AddNewSourceBuffer(std::move(Buffer), llvm::SMLoc());

std::unique_ptr<llvm::MCStreamer> Str(createNullStreamer(Ctx));

std::unique_ptr<llvm::MCAsmParser>

(

createMCAsmParser(TempSrcMgr, Ctx, *Str.get(), *MAI));

std::unique_ptr<llvm::MCTargetAsmParser> TargetParser(

TheTarget->createMCAsmParser(*STI, *

, *MII, MCOptions));

(AsmLoc, diag::err_msasm_unable_to_create_target)

<<

;

std::unique_ptr<llvm::MCInstPrinter> IP(

TheTarget->createMCInstPrinter(llvm::Triple(TT), 1, *MAI, *MII, *MRI));

->setAssemblerDialect(1);

->setTargetParser(*TargetParser.get());

->setParsingMSInlineAsm(

);

TargetParser->setParsingMSInlineAsm(

);

ClangAsmParserCallback Callback(*

, AsmLoc, AsmString, AsmToks,

TargetParser->setSemaCallback(&Callback);

TempSrcMgr.setDiagHandler(ClangAsmParserCallback::DiagHandlerCallback,

std::string AsmStringIR;

(

->parseMSInlineAsm(AsmStringIR, NumOutputs, NumInputs, OpExprs,

Constraints, Clobbers, MII.get(), IP.get(),

llvm::erase_if(Clobbers, [](

std::string &

) {

==

||

==

;

ClobberRefs.insert(ClobberRefs.end(), Clobbers.begin(), Clobbers.end());

NumExprs = NumOutputs + NumInputs;

ConstraintRefs.resize(NumExprs);

Exprs.resize(NumExprs);

(

i = 0, e = NumExprs; i != e; ++i) {

*OpExpr =

*

(OpExprs[i].first);

(OpExprs[i].second)

ConstraintRefs[i] = StringRef(Constraints[i]);

Actions.

(AsmLoc, LBraceLocs[0], AsmToks, AsmStringIR,

NumOutputs, NumInputs, ConstraintRefs,

ClobberRefs, Exprs, EndLoc);

Parser::parseGNUAsmQualifierListOpt(GNUAsmQualifiers &AQ) {

GNUAsmQualifiers::AQ A = getGNUAsmQualifier(Tok);

(A == GNUAsmQualifiers::AQ_unspecified) {

(Tok.

(tok::l_paren)) {

(AQ.setAsmQualifier(A))

<< GNUAsmQualifiers::getQualifierName(A);

Parser::ParseAsmStatement(

&msAsm) {

assert(Tok.

(tok::kw_asm) &&

);

(

().AsmBlocks && !isGCCAsmStatement(Tok)) {

ParseMicrosoftAsmStatement(AsmLoc);

GNUAsmQualifiers GAQ;

(parseGNUAsmQualifierListOpt(GAQ))

(GAQ.isGoto() &&

().SpeculativeLoadHardening)

(

, diag::warn_slh_does_not_support_asm_goto);

AsmString(ParseAsmStringLiteral(

));

(!(

().GNUAsm || AsmString.isInvalid())) {

*SL = cast<StringLiteral>(AsmString.get());

(!SL->getString().trim().empty())

(

, diag::err_gnu_inline_asm_disabled);

(AsmString.isInvalid()) {

ExprVector Constraints;

(Tok.

(tok::r_paren)) {

AsmLoc,

, GAQ.isVolatile(),

0,

0,

, Constraints, Exprs,

AsmString.get(), Clobbers,

0,

.getCloseLocation());

AteExtraColon =

;

(Tok.

(tok::colon) || Tok.

(tok::coloncolon)) {

AteExtraColon = Tok.

(tok::coloncolon);

(!AteExtraColon && ParseAsmOperandsOpt(Names, Constraints, Exprs))

NumOutputs = Names.size();

(AteExtraColon || Tok.

(tok::colon) || Tok.

(tok::coloncolon)) {

AteExtraColon =

;

AteExtraColon = Tok.

(tok::coloncolon);

(!AteExtraColon && ParseAsmOperandsOpt(Names, Constraints, Exprs))

assert(Names.size() == Constraints.size() &&

Constraints.size() == Exprs.size() &&

);

NumInputs = Names.size() - NumOutputs;

(AteExtraColon || Tok.

(tok::colon) || Tok.

(tok::coloncolon)) {

AteExtraColon =

;

AteExtraColon = Tok.

(tok::coloncolon);

(!AteExtraColon && isTokenStringLiteral()) {

Clobber(ParseAsmStringLiteral(

));

(Clobber.isInvalid())

Clobbers.push_back(Clobber.get());

(!GAQ.isGoto() && (Tok.

(tok::r_paren) || AteExtraColon)) {

(Tok, diag::err_expected) << tok::r_paren;

NumLabels = 0;

(AteExtraColon || Tok.

(tok::colon)) {

(Tok.

(tok::identifier)) {

(Tok, diag::err_expected) << tok::identifier;

Exprs.push_back(Res.

());

}

(GAQ.isGoto()) {

(Tok, diag::err_expected) << tok::colon;

Actions.

(AsmLoc,

, GAQ.isVolatile(), NumOutputs,

NumInputs, Names.data(), Constraints, Exprs,

AsmString.get(), Clobbers, NumLabels,

.getCloseLocation());

(!isTokenStringLiteral() && Tok.

(tok::l_square))

(Tok.

(tok::l_square)) {

(Tok.

(tok::identifier)) {

(Tok, diag::err_expected) << tok::identifier;

Names.push_back(

);

Constraint(ParseAsmStringLiteral(

));

(Constraint.isInvalid()) {

Constraints.push_back(Constraint.get());

(Tok.

(tok::l_paren)) {

(Tok, diag::err_expected_lparen_after) <<

;

Exprs.push_back(Res.

());

*Parser::GNUAsmQualifiers::getQualifierName(AQ Qualifier) {

AQ_volatile:

;

AQ_inline:

;

AQ_goto:

;

AQ_unspecified:

;

llvm_unreachable(

);

Parser::GNUAsmQualifiers::AQ

Parser::getGNUAsmQualifier(

&Tok)

{

tok::kw_volatile:

GNUAsmQualifiers::AQ_volatile;

tok::kw_inline:

GNUAsmQualifiers::AQ_inline;

tok::kw_goto:

GNUAsmQualifiers::AQ_goto;

:

GNUAsmQualifiers::AQ_unspecified;

Parser::GNUAsmQualifiers::setAsmQualifier(AQ Qualifier) {

Defines the clang::ASTContext interface.

Defines the Diagnostic-related interfaces.

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.

const TargetInfo & getTargetInfo() const

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.

This represents one expression.

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.

Parser - This implements a parser for the C family of languages.

DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)

SourceLocation ConsumeToken()

ConsumeToken - Consume the current 'peek token' and lex the next one.

Sema & getActions() const

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.

bool TryConsumeToken(tok::TokenKind Expected)

Scope * getCurScope() const

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 ...

const LangOptions & getLangOpts() const

ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)

Simple precedence-based parser for binary/ternary operators.

@ StopAtSemi

Stop skipping at semicolon.

const Token & NextToken()

NextToken - This peeks ahead one token and returns it without consuming it.

Engages in a tight little dance with the lexer to efficiently preprocess tokens.

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.

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)

ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input, bool IsAfterAmp=false)

ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, LabelDecl *TheDecl)

ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".

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.

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

Options for controlling the target.

std::vector< std::string > Features

The list of target specific features to enable or disable – this should be a list of strings starting...

std::string CPU

If given, the name of the target CPU to generate code for.

Token - This structure provides full information about a lexed token.

IdentifierInfo * getIdentifierInfo() const

void clearFlag(TokenFlags Flag)

Unset the specified flag.

SourceLocation getLocation() const

Return a source location identifier for the specified offset in the current file.

void setKind(tok::TokenKind K)

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)) {....

tok::TokenKind getKind() const

bool isAtStartOfLine() const

isAtStartOfLine - Return true if this token is at the start of a line.

bool hasLeadingSpace() const

Return true if this token has whitespace before it.

bool isNot(tok::TokenKind K) const

void startToken()

Reset all flags to cleared.

void setFlag(TokenFlags Flag)

Set the specified flag.

Represents a C++ unqualified-id that has been parsed.

Defines the clang::TargetInfo interface.

TokenKind

Provides a simple uniform namespace for tokens from all C languages.

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',...

@ Asm

Assembly: we accept this only so that we can preprocess it.

@ Result

The result type of a method or function.

const FunctionProtoType * T

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4