LCOV - code coverage report
Current view: top level - lib/CodeGen/MIRParser - MILexer.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 17 17 100.0 %
Date: 2018-02-22 04:41:24 Functions: 2 2 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- MILexer.h - Lexer for machine instructions ---------------*- C++ -*-===//
       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             : // This file declares the function that lexes the machine instruction source
      11             : // string.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #ifndef LLVM_LIB_CODEGEN_MIRPARSER_MILEXER_H
      16             : #define LLVM_LIB_CODEGEN_MIRPARSER_MILEXER_H
      17             : 
      18             : #include "llvm/ADT/APSInt.h"
      19             : #include "llvm/ADT/STLExtras.h"
      20             : #include "llvm/ADT/StringRef.h"
      21             : #include <string>
      22             : 
      23             : namespace llvm {
      24             : 
      25             : class Twine;
      26             : 
      27             : /// A token produced by the machine instruction lexer.
      28       17348 : struct MIToken {
      29             :   enum TokenKind {
      30             :     // Markers
      31             :     Eof,
      32             :     Error,
      33             :     Newline,
      34             : 
      35             :     // Tokens with no info.
      36             :     comma,
      37             :     equal,
      38             :     underscore,
      39             :     colon,
      40             :     coloncolon,
      41             :     dot,
      42             :     exclaim,
      43             :     lparen,
      44             :     rparen,
      45             :     lbrace,
      46             :     rbrace,
      47             :     plus,
      48             :     minus,
      49             :     less,
      50             :     greater,
      51             : 
      52             :     // Keywords
      53             :     kw_implicit,
      54             :     kw_implicit_define,
      55             :     kw_def,
      56             :     kw_dead,
      57             :     kw_dereferenceable,
      58             :     kw_killed,
      59             :     kw_undef,
      60             :     kw_internal,
      61             :     kw_early_clobber,
      62             :     kw_debug_use,
      63             :     kw_renamable,
      64             :     kw_tied_def,
      65             :     kw_frame_setup,
      66             :     kw_frame_destroy,
      67             :     kw_debug_location,
      68             :     kw_cfi_same_value,
      69             :     kw_cfi_offset,
      70             :     kw_cfi_rel_offset,
      71             :     kw_cfi_def_cfa_register,
      72             :     kw_cfi_def_cfa_offset,
      73             :     kw_cfi_adjust_cfa_offset,
      74             :     kw_cfi_escape,
      75             :     kw_cfi_def_cfa,
      76             :     kw_cfi_register,
      77             :     kw_cfi_remember_state,
      78             :     kw_cfi_restore,
      79             :     kw_cfi_restore_state,
      80             :     kw_cfi_undefined,
      81             :     kw_cfi_window_save,
      82             :     kw_blockaddress,
      83             :     kw_intrinsic,
      84             :     kw_target_index,
      85             :     kw_half,
      86             :     kw_float,
      87             :     kw_double,
      88             :     kw_x86_fp80,
      89             :     kw_fp128,
      90             :     kw_ppc_fp128,
      91             :     kw_target_flags,
      92             :     kw_volatile,
      93             :     kw_non_temporal,
      94             :     kw_invariant,
      95             :     kw_align,
      96             :     kw_addrspace,
      97             :     kw_stack,
      98             :     kw_got,
      99             :     kw_jump_table,
     100             :     kw_constant_pool,
     101             :     kw_call_entry,
     102             :     kw_liveout,
     103             :     kw_address_taken,
     104             :     kw_landing_pad,
     105             :     kw_liveins,
     106             :     kw_successors,
     107             :     kw_floatpred,
     108             :     kw_intpred,
     109             : 
     110             :     // Named metadata keywords
     111             :     md_tbaa,
     112             :     md_alias_scope,
     113             :     md_noalias,
     114             :     md_range,
     115             :     md_diexpr,
     116             : 
     117             :     // Identifier tokens
     118             :     Identifier,
     119             :     IntegerType,
     120             :     NamedRegister,
     121             :     MachineBasicBlockLabel,
     122             :     MachineBasicBlock,
     123             :     PointerType,
     124             :     ScalarType,
     125             :     StackObject,
     126             :     FixedStackObject,
     127             :     NamedGlobalValue,
     128             :     GlobalValue,
     129             :     ExternalSymbol,
     130             : 
     131             :     // Other tokens
     132             :     IntegerLiteral,
     133             :     FloatingPointLiteral,
     134             :     HexLiteral,
     135             :     VirtualRegister,
     136             :     ConstantPoolItem,
     137             :     JumpTableIndex,
     138             :     NamedIRBlock,
     139             :     IRBlock,
     140             :     NamedIRValue,
     141             :     IRValue,
     142             :     QuotedIRValue, // `<constant value>`
     143             :     SubRegisterIndex,
     144             :     StringConstant
     145             :   };
     146             : 
     147             : private:
     148             :   TokenKind Kind = Error;
     149             :   StringRef Range;
     150             :   StringRef StringValue;
     151             :   std::string StringValueStorage;
     152             :   APSInt IntVal;
     153             : 
     154             : public:
     155        8674 :   MIToken() = default;
     156             : 
     157             :   MIToken &reset(TokenKind Kind, StringRef Range);
     158             : 
     159             :   MIToken &setStringValue(StringRef StrVal);
     160             :   MIToken &setOwnedStringValue(std::string StrVal);
     161             :   MIToken &setIntegerValue(APSInt IntVal);
     162             : 
     163             :   TokenKind kind() const { return Kind; }
     164             : 
     165        4127 :   bool isError() const { return Kind == Error; }
     166             : 
     167      114194 :   bool isNewlineOrEOF() const { return Kind == Newline || Kind == Eof; }
     168             : 
     169             :   bool isErrorOrEOF() const { return Kind == Error || Kind == Eof; }
     170             : 
     171             :   bool isRegister() const {
     172      101535 :     return Kind == NamedRegister || Kind == underscore ||
     173             :            Kind == VirtualRegister;
     174             :   }
     175             : 
     176             :   bool isRegisterFlag() const {
     177             :     return Kind == kw_implicit || Kind == kw_implicit_define ||
     178      134579 :            Kind == kw_def || Kind == kw_dead || Kind == kw_killed ||
     179       60986 :            Kind == kw_undef || Kind == kw_internal ||
     180      134020 :            Kind == kw_early_clobber || Kind == kw_debug_use ||
     181             :            Kind == kw_renamable;
     182             :   }
     183             : 
     184             :   bool isMemoryOperandFlag() const {
     185        1969 :     return Kind == kw_volatile || Kind == kw_non_temporal ||
     186        1969 :            Kind == kw_dereferenceable || Kind == kw_invariant ||
     187             :            Kind == StringConstant;
     188             :   }
     189             : 
     190             :   bool is(TokenKind K) const { return Kind == K; }
     191             : 
     192             :   bool isNot(TokenKind K) const { return Kind != K; }
     193             : 
     194      208550 :   StringRef::iterator location() const { return Range.begin(); }
     195             : 
     196             :   StringRef range() const { return Range; }
     197             : 
     198             :   /// Return the token's string value.
     199             :   StringRef stringValue() const { return StringValue; }
     200             : 
     201             :   const APSInt &integerValue() const { return IntVal; }
     202             : 
     203       38160 :   bool hasIntegerValue() const {
     204       71707 :     return Kind == IntegerLiteral || Kind == MachineBasicBlock ||
     205       25394 :            Kind == MachineBasicBlockLabel || Kind == StackObject ||
     206       25084 :            Kind == FixedStackObject || Kind == GlobalValue ||
     207        1270 :            Kind == VirtualRegister || Kind == ConstantPoolItem ||
     208       39397 :            Kind == JumpTableIndex || Kind == IRBlock || Kind == IRValue;
     209             :   }
     210             : };
     211             : 
     212             : /// Consume a single machine instruction token in the given source and return
     213             : /// the remaining source string.
     214             : StringRef lexMIToken(
     215             :     StringRef Source, MIToken &Token,
     216             :     function_ref<void(StringRef::iterator, const Twine &)> ErrorCallback);
     217             : 
     218             : } // end namespace llvm
     219             : 
     220             : #endif // LLVM_LIB_CODEGEN_MIRPARSER_MILEXER_H

Generated by: LCOV version 1.13