Line data    Source code

       1             : //===-- MCAsmParser.cpp - Abstract Asm Parser Interface -------------------===//
       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             : #include "llvm/MC/MCParser/MCAsmParser.h"
      11             : #include "llvm/ADT/StringRef.h"
      12             : #include "llvm/ADT/Twine.h"
      13             : #include "llvm/Config/llvm-config.h"
      14             : #include "llvm/MC/MCParser/MCAsmLexer.h"
      15             : #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
      16             : #include "llvm/MC/MCParser/MCTargetAsmParser.h"
      17             : #include "llvm/Support/Debug.h"
      18             : #include "llvm/Support/SMLoc.h"
      19             : #include "llvm/Support/raw_ostream.h"
      20             : #include <cassert>
      21             : 
      22             : using namespace llvm;
      23             : 
      24       37106 : MCAsmParser::MCAsmParser() : ShowParsedOperands(0) {}
      25             : 
      26             : MCAsmParser::~MCAsmParser() = default;
      27             : 
      28       18544 : void MCAsmParser::setTargetParser(MCTargetAsmParser &P) {
      29             :   assert(!TargetParser && "Target parser is already initialized!");
      30       18544 :   TargetParser = &P;
      31       18544 :   TargetParser->Initialize(*this);
      32       18544 : }
      33             : 
      34    40004823 : const AsmToken &MCAsmParser::getTok() const {
      35    40004823 :   return getLexer().getTok();
      36             : }
      37             : 
      38         425 : bool MCAsmParser::parseTokenLoc(SMLoc &Loc) {
      39         425 :   Loc = getTok().getLoc();
      40         425 :   return false;
      41             : }
      42             : 
      43      127353 : bool MCAsmParser::parseEOL(const Twine &Msg) {
      44      127353 :   if (getTok().getKind() != AsmToken::EndOfStatement)
      45         156 :     return Error(getTok().getLoc(), Msg);
      46      127197 :   Lex();
      47      127197 :   return false;
      48             : }
      49             : 
      50      378503 : bool MCAsmParser::parseToken(AsmToken::TokenKind T, const Twine &Msg) {
      51      378503 :   if (T == AsmToken::EndOfStatement)
      52      127264 :     return parseEOL(Msg);
      53      251239 :   if (getTok().getKind() != T)
      54         118 :     return Error(getTok().getLoc(), Msg);
      55      251121 :   Lex();
      56      251121 :   return false;
      57             : }
      58             : 
      59         826 : bool MCAsmParser::parseIntToken(int64_t &V, const Twine &Msg) {
      60         826 :   if (getTok().getKind() != AsmToken::Integer)
      61           7 :     return TokError(Msg);
      62         819 :   V = getTok().getIntVal();
      63         819 :   Lex();
      64         819 :   return false;
      65             : }
      66             : 
      67      654842 : bool MCAsmParser::parseOptionalToken(AsmToken::TokenKind T) {
      68      654842 :   bool Present = (getTok().getKind() == T);
      69      654842 :   if (Present)
      70      196619 :     parseToken(T);
      71      654842 :   return Present;
      72             : }
      73             : 
      74        3676 : bool MCAsmParser::check(bool P, const Twine &Msg) {
      75        3676 :   return check(P, getTok().getLoc(), Msg);
      76             : }
      77             : 
      78        8812 : bool MCAsmParser::check(bool P, SMLoc Loc, const Twine &Msg) {
      79        8812 :   if (P)
      80          44 :     return Error(Loc, Msg);
      81             :   return false;
      82             : }
      83             : 
      84        2484 : bool MCAsmParser::TokError(const Twine &Msg, SMRange Range) {
      85        2484 :   return Error(getLexer().getLoc(), Msg, Range);
      86             : }
      87             : 
      88       44617 : bool MCAsmParser::Error(SMLoc L, const Twine &Msg, SMRange Range) {
      89             : 
      90             :   MCPendingError PErr;
      91       44617 :   PErr.Loc = L;
      92       44617 :   Msg.toVector(PErr.Msg);
      93       44617 :   PErr.Range = Range;
      94       44617 :   PendingErrors.push_back(PErr);
      95             : 
      96             :   // If we threw this parsing error after a lexing error, this should
      97             :   // supercede the lexing error and so we remove it from the Lexer
      98             :   // before it can propagate
      99       44617 :   if (getTok().is(AsmToken::Error))
     100          15 :     getLexer().Lex();
     101       44617 :   return true;
     102             : }
     103             : 
     104         195 : bool MCAsmParser::addErrorSuffix(const Twine &Suffix) {
     105             :   // Make sure lexing errors have propagated to the parser.
     106         195 :   if (getTok().is(AsmToken::Error))
     107           2 :     Lex();
     108         392 :   for (auto &PErr : PendingErrors)
     109         197 :     Suffix.toVector(PErr.Msg);
     110         195 :   return true;
     111             : }
     112             : 
     113       38455 : bool MCAsmParser::parseMany(function_ref<bool()> parseOne, bool hasComma) {
     114       38455 :   if (parseOptionalToken(AsmToken::EndOfStatement))
     115             :     return false;
     116             :   while (true) {
     117       39775 :     if (parseOne())
     118             :       return true;
     119       39717 :     if (parseOptionalToken(AsmToken::EndOfStatement))
     120             :       return false;
     121        1745 :     if (hasComma && parseToken(AsmToken::Comma))
     122         102 :       return true;
     123             :   }
     124             :   return false;
     125             : }
     126             : 
     127      109152 : bool MCAsmParser::parseExpression(const MCExpr *&Res) {
     128      109152 :   SMLoc L;
     129      109152 :   return parseExpression(Res, L);
     130             : }
     131             : 
     132           0 : void MCParsedAsmOperand::dump() const {
     133             :   // Cannot completely remove virtual function even in release mode.
     134             : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
     135             :   dbgs() << "  " << *this;
     136             : #endif
     137           0 : }