LCOV - code coverage report
Current view: top level - lib/CodeGen/MIRParser - MILexer.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 18 18 100.0 %
Date: 2018-06-17 00:07:59 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       22838 : 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_nnan,
      68             :     kw_ninf,
      69             :     kw_nsz,
      70             :     kw_arcp,
      71             :     kw_contract,
      72             :     kw_afn,
      73             :     kw_reassoc,
      74             :     kw_debug_location,
      75             :     kw_cfi_same_value,
      76             :     kw_cfi_offset,
      77             :     kw_cfi_rel_offset,
      78             :     kw_cfi_def_cfa_register,
      79             :     kw_cfi_def_cfa_offset,
      80             :     kw_cfi_adjust_cfa_offset,
      81             :     kw_cfi_escape,
      82             :     kw_cfi_def_cfa,
      83             :     kw_cfi_register,
      84             :     kw_cfi_remember_state,
      85             :     kw_cfi_restore,
      86             :     kw_cfi_restore_state,
      87             :     kw_cfi_undefined,
      88             :     kw_cfi_window_save,
      89             :     kw_blockaddress,
      90             :     kw_intrinsic,
      91             :     kw_target_index,
      92             :     kw_half,
      93             :     kw_float,
      94             :     kw_double,
      95             :     kw_x86_fp80,
      96             :     kw_fp128,
      97             :     kw_ppc_fp128,
      98             :     kw_target_flags,
      99             :     kw_volatile,
     100             :     kw_non_temporal,
     101             :     kw_invariant,
     102             :     kw_align,
     103             :     kw_addrspace,
     104             :     kw_stack,
     105             :     kw_got,
     106             :     kw_jump_table,
     107             :     kw_constant_pool,
     108             :     kw_call_entry,
     109             :     kw_liveout,
     110             :     kw_address_taken,
     111             :     kw_landing_pad,
     112             :     kw_liveins,
     113             :     kw_successors,
     114             :     kw_floatpred,
     115             :     kw_intpred,
     116             : 
     117             :     // Named metadata keywords
     118             :     md_tbaa,
     119             :     md_alias_scope,
     120             :     md_noalias,
     121             :     md_range,
     122             :     md_diexpr,
     123             : 
     124             :     // Identifier tokens
     125             :     Identifier,
     126             :     NamedRegister,
     127             :     NamedVirtualRegister,
     128             :     MachineBasicBlockLabel,
     129             :     MachineBasicBlock,
     130             :     StackObject,
     131             :     FixedStackObject,
     132             :     NamedGlobalValue,
     133             :     GlobalValue,
     134             :     ExternalSymbol,
     135             : 
     136             :     // Other tokens
     137             :     IntegerLiteral,
     138             :     FloatingPointLiteral,
     139             :     HexLiteral,
     140             :     VirtualRegister,
     141             :     ConstantPoolItem,
     142             :     JumpTableIndex,
     143             :     NamedIRBlock,
     144             :     IRBlock,
     145             :     NamedIRValue,
     146             :     IRValue,
     147             :     QuotedIRValue, // `<constant value>`
     148             :     SubRegisterIndex,
     149             :     StringConstant
     150             :   };
     151             : 
     152             : private:
     153             :   TokenKind Kind = Error;
     154             :   StringRef Range;
     155             :   StringRef StringValue;
     156             :   std::string StringValueStorage;
     157             :   APSInt IntVal;
     158             : 
     159             : public:
     160       11419 :   MIToken() = default;
     161             : 
     162             :   MIToken &reset(TokenKind Kind, StringRef Range);
     163             : 
     164             :   MIToken &setStringValue(StringRef StrVal);
     165             :   MIToken &setOwnedStringValue(std::string StrVal);
     166             :   MIToken &setIntegerValue(APSInt IntVal);
     167             : 
     168             :   TokenKind kind() const { return Kind; }
     169             : 
     170        5486 :   bool isError() const { return Kind == Error; }
     171             : 
     172      139160 :   bool isNewlineOrEOF() const { return Kind == Newline || Kind == Eof; }
     173             : 
     174             :   bool isErrorOrEOF() const { return Kind == Error || Kind == Eof; }
     175             : 
     176             :   bool isRegister() const {
     177      142674 :     return Kind == NamedRegister || Kind == underscore ||
     178      142606 :            Kind == NamedVirtualRegister || Kind == VirtualRegister;
     179             :   }
     180             : 
     181             :   bool isRegisterFlag() const {
     182             :     return Kind == kw_implicit || Kind == kw_implicit_define ||
     183      166264 :            Kind == kw_def || Kind == kw_dead || Kind == kw_killed ||
     184       74750 :            Kind == kw_undef || Kind == kw_internal ||
     185      165375 :            Kind == kw_early_clobber || Kind == kw_debug_use ||
     186             :            Kind == kw_renamable;
     187             :   }
     188             : 
     189             :   bool isMemoryOperandFlag() const {
     190        3194 :     return Kind == kw_volatile || Kind == kw_non_temporal ||
     191        3194 :            Kind == kw_dereferenceable || Kind == kw_invariant ||
     192             :            Kind == StringConstant;
     193             :   }
     194             : 
     195             :   bool is(TokenKind K) const { return Kind == K; }
     196             : 
     197             :   bool isNot(TokenKind K) const { return Kind != K; }
     198             : 
     199      254104 :   StringRef::iterator location() const { return Range.begin(); }
     200             : 
     201             :   StringRef range() const { return Range; }
     202             : 
     203             :   /// Return the token's string value.
     204             :   StringRef stringValue() const { return StringValue; }
     205             : 
     206             :   const APSInt &integerValue() const { return IntVal; }
     207             : 
     208       47842 :   bool hasIntegerValue() const {
     209       89369 :     return Kind == IntegerLiteral || Kind == MachineBasicBlock ||
     210       30656 :            Kind == MachineBasicBlockLabel || Kind == StackObject ||
     211       30162 :            Kind == FixedStackObject || Kind == GlobalValue ||
     212        1903 :            Kind == VirtualRegister || Kind == ConstantPoolItem ||
     213       49701 :            Kind == JumpTableIndex || Kind == IRBlock || Kind == IRValue;
     214             :   }
     215             : };
     216             : 
     217             : /// Consume a single machine instruction token in the given source and return
     218             : /// the remaining source string.
     219             : StringRef lexMIToken(
     220             :     StringRef Source, MIToken &Token,
     221             :     function_ref<void(StringRef::iterator, const Twine &)> ErrorCallback);
     222             : 
     223             : } // end namespace llvm
     224             : 
     225             : #endif // LLVM_LIB_CODEGEN_MIRPARSER_MILEXER_H

Generated by: LCOV version 1.13