Home | History | Annotate | Download | only in TableGen 
      1 //===- TGParser.h - Parser for TableGen Files -------------------*- 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 class represents the Parser for tablegen files.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #ifndef TGPARSER_H
     15 #define TGPARSER_H
     16 
     17 #include "TGLexer.h"
     18 #include "llvm/TableGen/Error.h"
     19 #include "llvm/ADT/Twine.h"
     20 #include "llvm/Support/SourceMgr.h"
     21 #include <map>
     22 
     23 namespace llvm {
     24   class Record;
     25   class RecordVal;
     26   class RecordKeeper;
     27   class RecTy;
     28   class Init;
     29   struct MultiClass;
     30   struct SubClassReference;
     31   struct SubMultiClassReference;
     32 
     33   struct LetRecord {
     34     std::string Name;
     35     std::vector<unsigned> Bits;
     36     Init *Value;
     37     SMLoc Loc;
     38     LetRecord(const std::string &N, const std::vector<unsigned> &B, Init *V,
     39               SMLoc L)
     40       : Name(N), Bits(B), Value(V), Loc(L) {
     41     }
     42   };
     43 
     44 class TGParser {
     45   TGLexer Lex;
     46   std::vector<std::vector<LetRecord> > LetStack;
     47   std::map<std::string, MultiClass*> MultiClasses;
     48 
     49   /// CurMultiClass - If we are parsing a 'multiclass' definition, this is the
     50   /// current value.
     51   MultiClass *CurMultiClass;
     52 
     53   // Record tracker
     54   RecordKeeper &Records;
     55 public:
     56   TGParser(SourceMgr &SrcMgr, RecordKeeper &records) :
     57     Lex(SrcMgr), CurMultiClass(0), Records(records) {}
     58 
     59   /// ParseFile - Main entrypoint for parsing a tblgen file.  These parser
     60   /// routines return true on error, or false on success.
     61   bool ParseFile();
     62 
     63   bool Error(SMLoc L, const Twine &Msg) const {
     64     PrintError(L, Msg);
     65     return true;
     66   }
     67   bool TokError(const Twine &Msg) const {
     68     return Error(Lex.getLoc(), Msg);
     69   }
     70   const std::vector<std::string> &getDependencies() const {
     71     return Lex.getDependencies();
     72   }
     73 private:  // Semantic analysis methods.
     74   bool AddValue(Record *TheRec, SMLoc Loc, const RecordVal &RV);
     75   bool SetValue(Record *TheRec, SMLoc Loc, const std::string &ValName,
     76                 const std::vector<unsigned> &BitList, Init *V);
     77   bool AddSubClass(Record *Rec, SubClassReference &SubClass);
     78   bool AddSubMultiClass(MultiClass *CurMC,
     79                         SubMultiClassReference &SubMultiClass);
     80 
     81 private:  // Parser methods.
     82   bool ParseObjectList(MultiClass *MC = 0);
     83   bool ParseObject(MultiClass *MC);
     84   bool ParseClass();
     85   bool ParseMultiClass();
     86   Record *InstantiateMulticlassDef(MultiClass &MC,
     87                                    Record *DefProto,
     88                                    const std::string &DefmPrefix,
     89                                    SMLoc DefmPrefixLoc);
     90   bool ResolveMulticlassDefArgs(MultiClass &MC,
     91                                 Record *DefProto,
     92                                 SMLoc DefmPrefixLoc,
     93                                 SMLoc SubClassLoc,
     94                                 const std::vector<std::string> &TArgs,
     95                                 std::vector<Init *> &TemplateVals,
     96                                 bool DeleteArgs);
     97   bool ResolveMulticlassDef(MultiClass &MC,
     98                             Record *CurRec,
     99                             Record *DefProto,
    100                             SMLoc DefmPrefixLoc);
    101   bool ParseDefm(MultiClass *CurMultiClass);
    102   bool ParseDef(MultiClass *CurMultiClass);
    103   bool ParseTopLevelLet(MultiClass *CurMultiClass);
    104   std::vector<LetRecord> ParseLetList();
    105 
    106   bool ParseObjectBody(Record *CurRec);
    107   bool ParseBody(Record *CurRec);
    108   bool ParseBodyItem(Record *CurRec);
    109 
    110   bool ParseTemplateArgList(Record *CurRec);
    111   std::string ParseDeclaration(Record *CurRec, bool ParsingTemplateArgs);
    112 
    113   SubClassReference ParseSubClassReference(Record *CurRec, bool isDefm);
    114   SubMultiClassReference ParseSubMultiClassReference(MultiClass *CurMC);
    115 
    116   Init *ParseIDValue(Record *CurRec);
    117   Init *ParseIDValue(Record *CurRec, const std::string &Name, SMLoc NameLoc);
    118   Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = 0);
    119   Init *ParseValue(Record *CurRec, RecTy *ItemType = 0);
    120   std::vector<Init*> ParseValueList(Record *CurRec, Record *ArgsRec = 0, RecTy *EltTy = 0);
    121   std::vector<std::pair<llvm::Init*, std::string> > ParseDagArgList(Record *);
    122   bool ParseOptionalRangeList(std::vector<unsigned> &Ranges);
    123   bool ParseOptionalBitList(std::vector<unsigned> &Ranges);
    124   std::vector<unsigned> ParseRangeList();
    125   bool ParseRangePiece(std::vector<unsigned> &Ranges);
    126   RecTy *ParseType();
    127   Init *ParseOperation(Record *CurRec);
    128   RecTy *ParseOperatorType();
    129   std::string ParseObjectName();
    130   Record *ParseClassID();
    131   MultiClass *ParseMultiClassID();
    132   Record *ParseDefmID();
    133 };
    134 
    135 } // end namespace llvm
    136 
    137 #endif
    138