]>
Commit | Line | Data |
---|---|---|
85aaf69f SL |
1 | //===-- AMDGPUAsmParser.cpp - Parse SI asm to MCInst instructions ----------===// |
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 "MCTargetDesc/AMDGPUMCTargetDesc.h" | |
11 | #include "llvm/ADT/SmallString.h" | |
12 | #include "llvm/ADT/SmallVector.h" | |
13 | #include "llvm/ADT/STLExtras.h" | |
14 | #include "llvm/ADT/StringSwitch.h" | |
15 | #include "llvm/ADT/Twine.h" | |
16 | #include "llvm/MC/MCContext.h" | |
17 | #include "llvm/MC/MCExpr.h" | |
18 | #include "llvm/MC/MCInst.h" | |
19 | #include "llvm/MC/MCInstrInfo.h" | |
20 | #include "llvm/MC/MCParser/MCAsmLexer.h" | |
21 | #include "llvm/MC/MCParser/MCAsmParser.h" | |
22 | #include "llvm/MC/MCParser/MCParsedAsmOperand.h" | |
23 | #include "llvm/MC/MCRegisterInfo.h" | |
24 | #include "llvm/MC/MCStreamer.h" | |
25 | #include "llvm/MC/MCSubtargetInfo.h" | |
26 | #include "llvm/MC/MCTargetAsmParser.h" | |
27 | #include "llvm/Support/SourceMgr.h" | |
28 | #include "llvm/Support/TargetRegistry.h" | |
29 | #include "llvm/Support/raw_ostream.h" | |
30 | ||
31 | using namespace llvm; | |
32 | ||
33 | namespace { | |
34 | ||
35 | class AMDGPUAsmParser : public MCTargetAsmParser { | |
36 | MCSubtargetInfo &STI; | |
37 | MCAsmParser &Parser; | |
38 | ||
39 | ||
40 | /// @name Auto-generated Match Functions | |
41 | /// { | |
42 | ||
43 | #define GET_ASSEMBLER_HEADER | |
44 | #include "AMDGPUGenAsmMatcher.inc" | |
45 | ||
46 | /// } | |
47 | ||
48 | public: | |
49 | AMDGPUAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser, | |
50 | const MCInstrInfo &_MII, | |
51 | const MCTargetOptions &Options) | |
52 | : MCTargetAsmParser(), STI(_STI), Parser(_Parser) { | |
53 | setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits())); | |
54 | } | |
55 | bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override; | |
56 | bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode, | |
57 | OperandVector &Operands, MCStreamer &Out, | |
58 | uint64_t &ErrorInfo, | |
59 | bool MatchingInlineAsm) override; | |
60 | bool ParseDirective(AsmToken DirectiveID) override; | |
61 | OperandMatchResultTy parseOperand(OperandVector &Operands, StringRef Mnemonic); | |
62 | bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name, | |
63 | SMLoc NameLoc, OperandVector &Operands) override; | |
64 | ||
65 | bool parseCnt(int64_t &IntVal); | |
66 | OperandMatchResultTy parseSWaitCntOps(OperandVector &Operands); | |
67 | }; | |
68 | ||
69 | class AMDGPUOperand : public MCParsedAsmOperand { | |
70 | enum KindTy { | |
71 | Token, | |
72 | Immediate | |
73 | } Kind; | |
74 | ||
75 | public: | |
76 | AMDGPUOperand(enum KindTy K) : MCParsedAsmOperand(), Kind(K) {} | |
77 | ||
78 | struct TokOp { | |
79 | const char *Data; | |
80 | unsigned Length; | |
81 | }; | |
82 | ||
83 | struct ImmOp { | |
84 | int64_t Val; | |
85 | }; | |
86 | ||
87 | union { | |
88 | TokOp Tok; | |
89 | ImmOp Imm; | |
90 | }; | |
91 | ||
92 | void addImmOperands(MCInst &Inst, unsigned N) const { | |
93 | Inst.addOperand(MCOperand::CreateImm(getImm())); | |
94 | } | |
95 | void addRegOperands(MCInst &Inst, unsigned N) const { | |
96 | llvm_unreachable("addRegOperands"); | |
97 | } | |
98 | StringRef getToken() const { | |
99 | return StringRef(Tok.Data, Tok.Length); | |
100 | } | |
101 | bool isToken() const override { | |
102 | return Kind == Token; | |
103 | } | |
104 | ||
105 | bool isImm() const override { | |
106 | return Kind == Immediate; | |
107 | } | |
108 | ||
109 | int64_t getImm() const { | |
110 | return Imm.Val; | |
111 | } | |
112 | ||
113 | bool isReg() const override { | |
114 | return false; | |
115 | } | |
116 | ||
117 | unsigned getReg() const override { | |
118 | return 0; | |
119 | } | |
120 | ||
121 | bool isMem() const override { | |
122 | return false; | |
123 | } | |
124 | ||
125 | SMLoc getStartLoc() const override { | |
126 | return SMLoc(); | |
127 | } | |
128 | ||
129 | SMLoc getEndLoc() const override { | |
130 | return SMLoc(); | |
131 | } | |
132 | ||
133 | void print(raw_ostream &OS) const override { } | |
134 | ||
135 | static std::unique_ptr<AMDGPUOperand> CreateImm(int64_t Val) { | |
136 | auto Op = llvm::make_unique<AMDGPUOperand>(Immediate); | |
137 | Op->Imm.Val = Val; | |
138 | return Op; | |
139 | } | |
140 | ||
141 | static std::unique_ptr<AMDGPUOperand> CreateToken(StringRef Str, SMLoc Loc) { | |
142 | auto Res = llvm::make_unique<AMDGPUOperand>(Token); | |
143 | Res->Tok.Data = Str.data(); | |
144 | Res->Tok.Length = Str.size(); | |
145 | return Res; | |
146 | } | |
147 | ||
148 | bool isSWaitCnt() const; | |
149 | }; | |
150 | ||
151 | } | |
152 | ||
153 | bool AMDGPUAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) { | |
154 | return true; | |
155 | } | |
156 | ||
157 | ||
158 | bool AMDGPUAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode, | |
159 | OperandVector &Operands, | |
160 | MCStreamer &Out, | |
161 | uint64_t &ErrorInfo, | |
162 | bool MatchingInlineAsm) { | |
163 | MCInst Inst; | |
164 | ||
165 | switch (MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm)) { | |
166 | case Match_Success: | |
167 | Inst.setLoc(IDLoc); | |
168 | Out.EmitInstruction(Inst, STI); | |
169 | return false; | |
170 | case Match_MissingFeature: | |
171 | return Error(IDLoc, "instruction use requires an option to be enabled"); | |
172 | case Match_MnemonicFail: | |
173 | return Error(IDLoc, "unrecognized instruction mnemonic"); | |
174 | case Match_InvalidOperand: { | |
175 | if (ErrorInfo != ~0ULL) { | |
176 | if (ErrorInfo >= Operands.size()) | |
177 | return Error(IDLoc, "too few operands for instruction"); | |
178 | ||
179 | } | |
180 | return Error(IDLoc, "invalid operand for instruction"); | |
181 | } | |
182 | } | |
183 | llvm_unreachable("Implement any new match types added!"); | |
184 | } | |
185 | ||
186 | bool AMDGPUAsmParser::ParseDirective(AsmToken DirectiveID) { | |
187 | return true; | |
188 | } | |
189 | ||
190 | AMDGPUAsmParser::OperandMatchResultTy | |
191 | AMDGPUAsmParser::parseOperand(OperandVector &Operands, StringRef Mnemonic) { | |
192 | ||
193 | // Try to parse with a custom parser | |
194 | OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic); | |
195 | ||
196 | // If we successfully parsed the operand or if there as an error parsing, | |
197 | // we are done. | |
198 | if (ResTy == MatchOperand_Success || ResTy == MatchOperand_ParseFail) | |
199 | return ResTy; | |
200 | ||
201 | switch(getLexer().getKind()) { | |
202 | case AsmToken::Integer: { | |
203 | int64_t IntVal; | |
204 | if (getParser().parseAbsoluteExpression(IntVal)) | |
205 | return MatchOperand_ParseFail; | |
206 | Operands.push_back(AMDGPUOperand::CreateImm(IntVal)); | |
207 | return MatchOperand_Success; | |
208 | } | |
209 | default: | |
210 | return MatchOperand_NoMatch; | |
211 | } | |
212 | } | |
213 | ||
214 | bool AMDGPUAsmParser::ParseInstruction(ParseInstructionInfo &Info, | |
215 | StringRef Name, | |
216 | SMLoc NameLoc, OperandVector &Operands) { | |
217 | // Add the instruction mnemonic | |
218 | Operands.push_back(AMDGPUOperand::CreateToken(Name, NameLoc)); | |
219 | ||
220 | if (getLexer().is(AsmToken::EndOfStatement)) | |
221 | return false; | |
222 | ||
223 | AMDGPUAsmParser::OperandMatchResultTy Res = parseOperand(Operands, Name); | |
224 | switch (Res) { | |
225 | case MatchOperand_Success: return false; | |
226 | case MatchOperand_ParseFail: return Error(NameLoc, | |
227 | "Failed parsing operand"); | |
228 | case MatchOperand_NoMatch: return Error(NameLoc, "Not a valid operand"); | |
229 | } | |
230 | return true; | |
231 | } | |
232 | ||
233 | //===----------------------------------------------------------------------===// | |
234 | // s_waitcnt | |
235 | //===----------------------------------------------------------------------===// | |
236 | ||
237 | bool AMDGPUAsmParser::parseCnt(int64_t &IntVal) { | |
238 | StringRef CntName = Parser.getTok().getString(); | |
239 | int64_t CntVal; | |
240 | ||
241 | Parser.Lex(); | |
242 | if (getLexer().isNot(AsmToken::LParen)) | |
243 | return true; | |
244 | ||
245 | Parser.Lex(); | |
246 | if (getLexer().isNot(AsmToken::Integer)) | |
247 | return true; | |
248 | ||
249 | if (getParser().parseAbsoluteExpression(CntVal)) | |
250 | return true; | |
251 | ||
252 | if (getLexer().isNot(AsmToken::RParen)) | |
253 | return true; | |
254 | ||
255 | Parser.Lex(); | |
256 | if (getLexer().is(AsmToken::Amp) || getLexer().is(AsmToken::Comma)) | |
257 | Parser.Lex(); | |
258 | ||
259 | int CntShift; | |
260 | int CntMask; | |
261 | ||
262 | if (CntName == "vmcnt") { | |
263 | CntMask = 0xf; | |
264 | CntShift = 0; | |
265 | } else if (CntName == "expcnt") { | |
266 | CntMask = 0x7; | |
267 | CntShift = 4; | |
268 | } else if (CntName == "lgkmcnt") { | |
269 | CntMask = 0x7; | |
270 | CntShift = 8; | |
271 | } else { | |
272 | return true; | |
273 | } | |
274 | ||
275 | IntVal &= ~(CntMask << CntShift); | |
276 | IntVal |= (CntVal << CntShift); | |
277 | return false; | |
278 | } | |
279 | ||
280 | AMDGPUAsmParser::OperandMatchResultTy | |
281 | AMDGPUAsmParser::parseSWaitCntOps(OperandVector &Operands) { | |
282 | // Disable all counters by default. | |
283 | // vmcnt [3:0] | |
284 | // expcnt [6:4] | |
285 | // lgkmcnt [10:8] | |
286 | int64_t CntVal = 0x77f; | |
287 | ||
288 | switch(getLexer().getKind()) { | |
289 | default: return MatchOperand_ParseFail; | |
290 | case AsmToken::Integer: | |
291 | // The operand can be an integer value. | |
292 | if (getParser().parseAbsoluteExpression(CntVal)) | |
293 | return MatchOperand_ParseFail; | |
294 | break; | |
295 | ||
296 | case AsmToken::Identifier: | |
297 | do { | |
298 | if (parseCnt(CntVal)) | |
299 | return MatchOperand_ParseFail; | |
300 | } while(getLexer().isNot(AsmToken::EndOfStatement)); | |
301 | break; | |
302 | } | |
303 | Operands.push_back(AMDGPUOperand::CreateImm(CntVal)); | |
304 | return MatchOperand_Success; | |
305 | } | |
306 | ||
307 | bool AMDGPUOperand::isSWaitCnt() const { | |
308 | return isImm(); | |
309 | } | |
310 | ||
311 | /// Force static initialization. | |
312 | extern "C" void LLVMInitializeR600AsmParser() { | |
313 | RegisterMCAsmParser<AMDGPUAsmParser> A(TheAMDGPUTarget); | |
314 | RegisterMCAsmParser<AMDGPUAsmParser> B(TheGCNTarget); | |
315 | } | |
316 | ||
317 | #define GET_REGISTER_MATCHER | |
318 | #define GET_MATCHER_IMPLEMENTATION | |
319 | #include "AMDGPUGenAsmMatcher.inc" | |
320 |