LCOV - code coverage report
Current view: top level - lib/MC/MCParser - MCAsmParser.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 64 66 97.0 %
Date: 2017-09-14 15:23:50 Functions: 15 16 93.8 %
Legend: Lines: hit not hit

          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/MC/MCParser/MCAsmLexer.h"
      14             : #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
      15             : #include "llvm/MC/MCParser/MCTargetAsmParser.h"
      16             : #include "llvm/Support/Debug.h"
      17             : #include "llvm/Support/SMLoc.h"
      18             : #include "llvm/Support/raw_ostream.h"
      19             : #include <cassert>
      20             : 
      21             : using namespace llvm;
      22             : 
      23       14882 : MCAsmParser::MCAsmParser() : ShowParsedOperands(0) {}
      24             : 
      25             : MCAsmParser::~MCAsmParser() = default;
      26             : 
      27        7437 : void MCAsmParser::setTargetParser(MCTargetAsmParser &P) {
      28             :   assert(!TargetParser && "Target parser is already initialized!");
      29        7437 :   TargetParser = &P;
      30        7437 :   TargetParser->Initialize(*this);
      31        7437 : }
      32             : 
      33    24184183 : const AsmToken &MCAsmParser::getTok() const {
      34    48368366 :   return getLexer().getTok();
      35             : }
      36             : 
      37         332 : bool MCAsmParser::parseTokenLoc(SMLoc &Loc) {
      38         332 :   Loc = getTok().getLoc();
      39         332 :   return false;
      40             : }
      41             : 
      42       63631 : bool MCAsmParser::parseEOL(const Twine &Msg) {
      43       63631 :   if (getTok().getKind() != AsmToken::EndOfStatement)
      44         159 :     return Error(getTok().getLoc(), Msg);
      45       63472 :   Lex();
      46       63472 :   return false;
      47             : }
      48             : 
      49      149335 : bool MCAsmParser::parseToken(AsmToken::TokenKind T, const Twine &Msg) {
      50      149335 :   if (T == AsmToken::EndOfStatement)
      51       63631 :     return parseEOL(Msg);
      52       85704 :   if (getTok().getKind() != T)
      53         118 :     return Error(getTok().getLoc(), Msg);
      54       85586 :   Lex();
      55       85586 :   return false;
      56             : }
      57             : 
      58         395 : bool MCAsmParser::parseIntToken(int64_t &V, const Twine &Msg) {
      59         395 :   if (getTok().getKind() != AsmToken::Integer)
      60           5 :     return TokError(Msg);
      61         780 :   V = getTok().getIntVal();
      62         390 :   Lex();
      63         390 :   return false;
      64             : }
      65             : 
      66      227713 : bool MCAsmParser::parseOptionalToken(AsmToken::TokenKind T) {
      67      227713 :   bool Present = (getTok().getKind() == T);
      68      227713 :   if (Present)
      69       89415 :     parseToken(T);
      70      227713 :   return Present;
      71             : }
      72             : 
      73        1127 : bool MCAsmParser::check(bool P, const Twine &Msg) {
      74        1127 :   return check(P, getTok().getLoc(), Msg);
      75             : }
      76             : 
      77        4402 : bool MCAsmParser::check(bool P, SMLoc Loc, const Twine &Msg) {
      78        4402 :   if (P)
      79          36 :     return Error(Loc, Msg);
      80             :   return false;
      81             : }
      82             : 
      83        1731 : bool MCAsmParser::TokError(const Twine &Msg, SMRange Range) {
      84        1731 :   return Error(getLexer().getLoc(), Msg, Range);
      85             : }
      86             : 
      87       29489 : bool MCAsmParser::Error(SMLoc L, const Twine &Msg, SMRange Range) {
      88       29489 :   HadError = true;
      89             : 
      90       58978 :   MCPendingError PErr;
      91       29489 :   PErr.Loc = L;
      92       29489 :   Msg.toVector(PErr.Msg);
      93       29489 :   PErr.Range = Range;
      94       29489 :   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       29489 :   if (getTok().is(AsmToken::Error))
     100          14 :     getLexer().Lex();
     101       58978 :   return true;
     102             : }
     103             : 
     104         177 : bool MCAsmParser::addErrorSuffix(const Twine &Suffix) {
     105             :   // Make sure lexing errors have propagated to the parser.
     106         177 :   if (getTok().is(AsmToken::Error))
     107           2 :     Lex();
     108         709 :   for (auto &PErr : PendingErrors)
     109         178 :     Suffix.toVector(PErr.Msg);
     110         177 :   return true;
     111             : }
     112             : 
     113       10657 : bool MCAsmParser::parseMany(function_ref<bool()> parseOne, bool hasComma) {
     114       10657 :   if (parseOptionalToken(AsmToken::EndOfStatement))
     115             :     return false;
     116             :   while (true) {
     117       11187 :     if (parseOne())
     118             :       return true;
     119       11140 :     if (parseOptionalToken(AsmToken::EndOfStatement))
     120             :       return false;
     121        1560 :     if (hasComma && parseToken(AsmToken::Comma))
     122             :       return true;
     123             :   }
     124             :   return false;
     125             : }
     126             : 
     127       81569 : bool MCAsmParser::parseExpression(const MCExpr *&Res) {
     128       81569 :   SMLoc L;
     129       81569 :   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 : }

Generated by: LCOV version 1.13