1 //===- MIParser.h - Machine Instructions Parser -----------------*- 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 parses the machine instructions.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_LIB_CODEGEN_MIRPARSER_MIPARSER_H
15 #define LLVM_LIB_CODEGEN_MIRPARSER_MIPARSER_H
16 
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/ADT/StringMap.h"
19 #include "llvm/Support/Allocator.h"
20 
21 namespace llvm {
22 
23 class MachineBasicBlock;
24 class MachineFunction;
25 class MDNode;
26 class RegisterBank;
27 struct SlotMapping;
28 class SMDiagnostic;
29 class SourceMgr;
30 class StringRef;
31 class TargetRegisterClass;
32 
33 struct VRegInfo {
34   enum uint8_t {
35     UNKNOWN, NORMAL, GENERIC, REGBANK
36   } Kind = UNKNOWN;
37   bool Explicit = false; ///< VReg was explicitly specified in the .mir file.
38   union {
39     const TargetRegisterClass *RC;
40     const RegisterBank *RegBank;
41   } D;
42   unsigned VReg;
43   unsigned PreferredReg = 0;
44 };
45 
46 using Name2RegClassMap = StringMap<const TargetRegisterClass *>;
47 using Name2RegBankMap = StringMap<const RegisterBank *>;
48 
49 struct PerFunctionMIParsingState {
50   BumpPtrAllocator Allocator;
51   MachineFunction &MF;
52   SourceMgr *SM;
53   const SlotMapping &IRSlots;
54   const Name2RegClassMap &Names2RegClasses;
55   const Name2RegBankMap &Names2RegBanks;
56 
57   DenseMap<unsigned, MachineBasicBlock *> MBBSlots;
58   DenseMap<unsigned, VRegInfo*> VRegInfos;
59   StringMap<VRegInfo*> VRegInfosNamed;
60   DenseMap<unsigned, int> FixedStackObjectSlots;
61   DenseMap<unsigned, int> StackObjectSlots;
62   DenseMap<unsigned, unsigned> ConstantPoolSlots;
63   DenseMap<unsigned, unsigned> JumpTableSlots;
64 
65   PerFunctionMIParsingState(MachineFunction &MF, SourceMgr &SM,
66                             const SlotMapping &IRSlots,
67                             const Name2RegClassMap &Names2RegClasses,
68                             const Name2RegBankMap &Names2RegBanks);
69 
70   VRegInfo &getVRegInfo(unsigned Num);
71   VRegInfo &getVRegInfoNamed(StringRef RegName);
72 };
73 
74 /// Parse the machine basic block definitions, and skip the machine
75 /// instructions.
76 ///
77 /// This function runs the first parsing pass on the machine function's body.
78 /// It parses only the machine basic block definitions and creates the machine
79 /// basic blocks in the given machine function.
80 ///
81 /// The machine instructions aren't parsed during the first pass because all
82 /// the machine basic blocks aren't defined yet - this makes it impossible to
83 /// resolve the machine basic block references.
84 ///
85 /// Return true if an error occurred.
86 bool parseMachineBasicBlockDefinitions(PerFunctionMIParsingState &PFS,
87                                        StringRef Src, SMDiagnostic &Error);
88 
89 /// Parse the machine instructions.
90 ///
91 /// This function runs the second parsing pass on the machine function's body.
92 /// It skips the machine basic block definitions and parses only the machine
93 /// instructions and basic block attributes like liveins and successors.
94 ///
95 /// The second parsing pass assumes that the first parsing pass already ran
96 /// on the given source string.
97 ///
98 /// Return true if an error occurred.
99 bool parseMachineInstructions(PerFunctionMIParsingState &PFS, StringRef Src,
100                               SMDiagnostic &Error);
101 
102 bool parseMBBReference(PerFunctionMIParsingState &PFS,
103                        MachineBasicBlock *&MBB, StringRef Src,
104                        SMDiagnostic &Error);
105 
106 bool parseRegisterReference(PerFunctionMIParsingState &PFS,
107                             unsigned &Reg, StringRef Src,
108                             SMDiagnostic &Error);
109 
110 bool parseNamedRegisterReference(PerFunctionMIParsingState &PFS, unsigned &Reg,
111                                  StringRef Src, SMDiagnostic &Error);
112 
113 bool parseVirtualRegisterReference(PerFunctionMIParsingState &PFS,
114                                    VRegInfo *&Info, StringRef Src,
115                                    SMDiagnostic &Error);
116 
117 bool parseStackObjectReference(PerFunctionMIParsingState &PFS, int &FI,
118                                StringRef Src, SMDiagnostic &Error);
119 
120 bool parseMDNode(PerFunctionMIParsingState &PFS, MDNode *&Node, StringRef Src,
121                  SMDiagnostic &Error);
122 
123 } // end namespace llvm
124 
125 #endif // LLVM_LIB_CODEGEN_MIRPARSER_MIPARSER_H
126