LCOV - code coverage report
Current view: top level - lib/MC/MCParser - MCAsmParser.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 62 64 96.9 %
Date: 2018-07-13 00:08:38 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/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       34884 : MCAsmParser::MCAsmParser() : ShowParsedOperands(0) {}
      25             : 
      26             : MCAsmParser::~MCAsmParser() = default;
      27             : 
      28       17433 : void MCAsmParser::setTargetParser(MCTargetAsmParser &P) {
      29             :   assert(!TargetParser && "Target parser is already initialized!");
      30       17433 :   TargetParser = &P;
      31       17433 :   TargetParser->Initialize(*this);
      32       17433 : }
      33             : 
      34    37132761 : const AsmToken &MCAsmParser::getTok() const {
      35    37132761 :   return getLexer().getTok();
      36             : }
      37             : 
      38         392 : bool MCAsmParser::parseTokenLoc(SMLoc &Loc) {
      39         392 :   Loc = getTok().getLoc();
      40         392 :   return false;
      41             : }
      42             : 
      43      115465 : bool MCAsmParser::parseEOL(const Twine &Msg) {
      44      115465 :   if (getTok().getKind() != AsmToken::EndOfStatement)
      45         156 :     return Error(getTok().getLoc(), Msg);
      46      115309 :   Lex();
      47      115309 :   return false;
      48             : }
      49             : 
      50      345329 : bool MCAsmParser::parseToken(AsmToken::TokenKind T, const Twine &Msg) {
      51      345329 :   if (T == AsmToken::EndOfStatement)
      52      115389 :     return parseEOL(Msg);
      53      229940 :   if (getTok().getKind() != T)
      54         118 :     return Error(getTok().getLoc(), Msg);
      55      229822 :   Lex();
      56      229822 :   return false;
      57             : }
      58             : 
      59         725 : bool MCAsmParser::parseIntToken(int64_t &V, const Twine &Msg) {
      60         725 :   if (getTok().getKind() != AsmToken::Integer)
      61           7 :     return TokError(Msg);
      62        1436 :   V = getTok().getIntVal();
      63         718 :   Lex();
      64         718 :   return false;
      65             : }
      66             : 
      67      497223 : bool MCAsmParser::parseOptionalToken(AsmToken::TokenKind T) {
      68      497223 :   bool Present = (getTok().getKind() == T);
      69      497223 :   if (Present)
      70      176623 :     parseToken(T);
      71      497223 :   return Present;
      72             : }
      73             : 
      74        3451 : bool MCAsmParser::check(bool P, const Twine &Msg) {
      75        3451 :   return check(P, getTok().getLoc(), Msg);
      76             : }
      77             : 
      78        8180 : bool MCAsmParser::check(bool P, SMLoc Loc, const Twine &Msg) {
      79        8180 :   if (P)
      80          44 :     return Error(Loc, Msg);
      81             :   return false;
      82             : }
      83             : 
      84        2436 : bool MCAsmParser::TokError(const Twine &Msg, SMRange Range) {
      85        2436 :   return Error(getLexer().getLoc(), Msg, Range);
      86             : }
      87             : 
      88       41599 : bool MCAsmParser::Error(SMLoc L, const Twine &Msg, SMRange Range) {
      89             : 
      90             :   MCPendingError PErr;
      91       41599 :   PErr.Loc = L;
      92       41599 :   Msg.toVector(PErr.Msg);
      93       41599 :   PErr.Range = Range;
      94       41599 :   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       41599 :   if (getTok().is(AsmToken::Error))
     100          15 :     getLexer().Lex();
     101       41599 :   return true;
     102             : }
     103             : 
     104         196 : bool MCAsmParser::addErrorSuffix(const Twine &Suffix) {
     105             :   // Make sure lexing errors have propagated to the parser.
     106         196 :   if (getTok().is(AsmToken::Error))
     107           2 :     Lex();
     108         592 :   for (auto &PErr : PendingErrors)
     109         198 :     Suffix.toVector(PErr.Msg);
     110         196 :   return true;
     111             : }
     112             : 
     113       35320 : bool MCAsmParser::parseMany(function_ref<bool()> parseOne, bool hasComma) {
     114       35320 :   if (parseOptionalToken(AsmToken::EndOfStatement))
     115             :     return false;
     116             :   while (true) {
     117       36066 :     if (parseOne())
     118             :       return true;
     119       36009 :     if (parseOptionalToken(AsmToken::EndOfStatement))
     120             :       return false;
     121        2258 :     if (hasComma && parseToken(AsmToken::Comma))
     122             :       return true;
     123             :   }
     124             :   return false;
     125             : }
     126             : 
     127      105150 : bool MCAsmParser::parseExpression(const MCExpr *&Res) {
     128      105150 :   SMLoc L;
     129      105150 :   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