blob: 2ee4f78259779c092f6448cde45954cc724c96bf [file] [log] [blame]
Alex Lorenz8e0a1b42015-06-22 17:02:30 +00001//===- MIParser.cpp - Machine instructions parser implementation ----------===//
2//
Chandler Carruth2946cd72019-01-19 08:50:56 +00003// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Alex Lorenz8e0a1b42015-06-22 17:02:30 +00006//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the parsing of machine instructions.
10//
11//===----------------------------------------------------------------------===//
12
Eugene Zelenkofb69e662017-06-06 22:22:41 +000013#include "MIParser.h"
David Blaikie3f833ed2017-11-08 01:01:31 +000014#include "MILexer.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000015#include "llvm/ADT/APInt.h"
16#include "llvm/ADT/APSInt.h"
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/DenseMap.h"
19#include "llvm/ADT/None.h"
20#include "llvm/ADT/Optional.h"
21#include "llvm/ADT/SmallVector.h"
Alex Lorenz8e0a1b42015-06-22 17:02:30 +000022#include "llvm/ADT/StringMap.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000023#include "llvm/ADT/StringRef.h"
David Blaikie3f833ed2017-11-08 01:01:31 +000024#include "llvm/ADT/StringSwitch.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000025#include "llvm/ADT/Twine.h"
Krzysztof Parzyszekcc3f6302018-08-20 20:37:57 +000026#include "llvm/Analysis/MemoryLocation.h"
Alex Lorenzad156fb2015-07-31 20:49:21 +000027#include "llvm/AsmParser/Parser.h"
Alex Lorenz5d6108e2015-06-26 22:56:48 +000028#include "llvm/AsmParser/SlotMapping.h"
Matthias Braun89401142017-05-05 21:09:30 +000029#include "llvm/CodeGen/MIRPrinter.h"
Alex Lorenz8e0a1b42015-06-22 17:02:30 +000030#include "llvm/CodeGen/MachineBasicBlock.h"
Alex Lorenz7feaf7c2015-07-16 23:37:45 +000031#include "llvm/CodeGen/MachineFrameInfo.h"
Quentin Colombet2a831fb2016-03-07 21:48:43 +000032#include "llvm/CodeGen/MachineFunction.h"
Alex Lorenz8e0a1b42015-06-22 17:02:30 +000033#include "llvm/CodeGen/MachineInstr.h"
Alex Lorenzcb268d42015-07-06 23:07:26 +000034#include "llvm/CodeGen/MachineInstrBuilder.h"
Alex Lorenz4af7e612015-08-03 23:08:19 +000035#include "llvm/CodeGen/MachineMemOperand.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000036#include "llvm/CodeGen/MachineOperand.h"
Quentin Colombet2a831fb2016-03-07 21:48:43 +000037#include "llvm/CodeGen/MachineRegisterInfo.h"
David Blaikie3f833ed2017-11-08 01:01:31 +000038#include "llvm/CodeGen/TargetInstrInfo.h"
David Blaikieb3bde2e2017-11-17 01:07:10 +000039#include "llvm/CodeGen/TargetRegisterInfo.h"
40#include "llvm/CodeGen/TargetSubtargetInfo.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000041#include "llvm/IR/BasicBlock.h"
Alex Lorenzdeb53492015-07-28 17:28:03 +000042#include "llvm/IR/Constants.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000043#include "llvm/IR/DataLayout.h"
Reid Kleckner6d353342017-08-23 20:31:27 +000044#include "llvm/IR/DebugInfoMetadata.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000045#include "llvm/IR/DebugLoc.h"
46#include "llvm/IR/Function.h"
47#include "llvm/IR/InstrTypes.h"
Quentin Colombet2a831fb2016-03-07 21:48:43 +000048#include "llvm/IR/Instructions.h"
Tim Northover6b3bd612016-07-29 20:32:59 +000049#include "llvm/IR/Intrinsics.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000050#include "llvm/IR/Metadata.h"
Alex Lorenz5d6108e2015-06-26 22:56:48 +000051#include "llvm/IR/Module.h"
Alex Lorenz8a1915b2015-07-27 22:42:41 +000052#include "llvm/IR/ModuleSlotTracker.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000053#include "llvm/IR/Type.h"
54#include "llvm/IR/Value.h"
Alex Lorenzdeb53492015-07-28 17:28:03 +000055#include "llvm/IR/ValueSymbolTable.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000056#include "llvm/MC/LaneBitmask.h"
Chandler Carruth75ca6be2018-08-16 23:11:05 +000057#include "llvm/MC/MCContext.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000058#include "llvm/MC/MCDwarf.h"
59#include "llvm/MC/MCInstrDesc.h"
60#include "llvm/MC/MCRegisterInfo.h"
61#include "llvm/Support/AtomicOrdering.h"
62#include "llvm/Support/BranchProbability.h"
63#include "llvm/Support/Casting.h"
64#include "llvm/Support/ErrorHandling.h"
65#include "llvm/Support/LowLevelTypeImpl.h"
66#include "llvm/Support/MemoryBuffer.h"
67#include "llvm/Support/SMLoc.h"
Alex Lorenz8e0a1b42015-06-22 17:02:30 +000068#include "llvm/Support/SourceMgr.h"
Quentin Colombet2a831fb2016-03-07 21:48:43 +000069#include "llvm/Support/raw_ostream.h"
Tim Northover6b3bd612016-07-29 20:32:59 +000070#include "llvm/Target/TargetIntrinsicInfo.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000071#include "llvm/Target/TargetMachine.h"
Eugene Zelenkofb69e662017-06-06 22:22:41 +000072#include <algorithm>
73#include <cassert>
Krzysztof Parzyszekd62669d2016-10-12 21:06:45 +000074#include <cctype>
Eugene Zelenkofb69e662017-06-06 22:22:41 +000075#include <cstddef>
76#include <cstdint>
77#include <limits>
78#include <string>
79#include <utility>
Alex Lorenz8e0a1b42015-06-22 17:02:30 +000080
81using namespace llvm;
82
Matthias Braune35861d2016-07-13 23:27:50 +000083PerFunctionMIParsingState::PerFunctionMIParsingState(MachineFunction &MF,
Matthias Braunde5fea22017-01-18 00:59:19 +000084 SourceMgr &SM, const SlotMapping &IRSlots,
85 const Name2RegClassMap &Names2RegClasses,
86 const Name2RegBankMap &Names2RegBanks)
87 : MF(MF), SM(&SM), IRSlots(IRSlots), Names2RegClasses(Names2RegClasses),
88 Names2RegBanks(Names2RegBanks) {
Matthias Braun83947862016-07-13 22:23:23 +000089}
90
Matthias Braun74ad41c2016-10-11 03:13:01 +000091VRegInfo &PerFunctionMIParsingState::getVRegInfo(unsigned Num) {
92 auto I = VRegInfos.insert(std::make_pair(Num, nullptr));
93 if (I.second) {
94 MachineRegisterInfo &MRI = MF.getRegInfo();
95 VRegInfo *Info = new (Allocator) VRegInfo;
96 Info->VReg = MRI.createIncompleteVirtualRegister();
97 I.first->second = Info;
98 }
99 return *I.first->second;
100}
101
Puyan Lotfi399b46c2018-03-30 18:15:54 +0000102VRegInfo &PerFunctionMIParsingState::getVRegInfoNamed(StringRef RegName) {
103 assert(RegName != "" && "Expected named reg.");
104
105 auto I = VRegInfosNamed.insert(std::make_pair(RegName.str(), nullptr));
106 if (I.second) {
107 VRegInfo *Info = new (Allocator) VRegInfo;
108 Info->VReg = MF.getRegInfo().createIncompleteVirtualRegister(RegName);
109 I.first->second = Info;
110 }
111 return *I.first->second;
112}
113
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000114namespace {
115
Alex Lorenz36962cd2015-07-07 02:08:46 +0000116/// A wrapper struct around the 'MachineOperand' struct that includes a source
Alex Lorenzfeb6b432015-08-19 19:19:16 +0000117/// range and other attributes.
118struct ParsedMachineOperand {
Alex Lorenz36962cd2015-07-07 02:08:46 +0000119 MachineOperand Operand;
120 StringRef::iterator Begin;
121 StringRef::iterator End;
Alex Lorenz5ef93b02015-08-19 19:05:34 +0000122 Optional<unsigned> TiedDefIdx;
Alex Lorenz36962cd2015-07-07 02:08:46 +0000123
Alex Lorenzfeb6b432015-08-19 19:19:16 +0000124 ParsedMachineOperand(const MachineOperand &Operand, StringRef::iterator Begin,
125 StringRef::iterator End, Optional<unsigned> &TiedDefIdx)
Alex Lorenz5ef93b02015-08-19 19:05:34 +0000126 : Operand(Operand), Begin(Begin), End(End), TiedDefIdx(TiedDefIdx) {
127 if (TiedDefIdx)
128 assert(Operand.isReg() && Operand.isUse() &&
129 "Only used register operands can be tied");
130 }
Alex Lorenz36962cd2015-07-07 02:08:46 +0000131};
132
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000133class MIParser {
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000134 MachineFunction &MF;
135 SMDiagnostic &Error;
Alex Lorenz91370c52015-06-22 20:37:46 +0000136 StringRef Source, CurrentSource;
137 MIToken Token;
Matthias Braun74ad41c2016-10-11 03:13:01 +0000138 PerFunctionMIParsingState &PFS;
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000139 /// Maps from instruction names to op codes.
140 StringMap<unsigned> Names2InstrOpCodes;
Alex Lorenzf3db51de2015-06-23 16:35:26 +0000141 /// Maps from register names to registers.
142 StringMap<unsigned> Names2Regs;
Alex Lorenz8f6f4282015-06-29 16:57:06 +0000143 /// Maps from register mask names to register masks.
144 StringMap<const uint32_t *> Names2RegMasks;
Alex Lorenz2eacca82015-07-13 23:24:34 +0000145 /// Maps from subregister names to subregister indices.
146 StringMap<unsigned> Names2SubRegIndices;
Alex Lorenz8a1915b2015-07-27 22:42:41 +0000147 /// Maps from slot numbers to function's unnamed basic blocks.
148 DenseMap<unsigned, const BasicBlock *> Slots2BasicBlocks;
Alex Lorenzdd13be02015-08-19 23:31:05 +0000149 /// Maps from slot numbers to function's unnamed values.
150 DenseMap<unsigned, const Value *> Slots2Values;
Alex Lorenzef5c1962015-07-28 23:02:45 +0000151 /// Maps from target index names to target indices.
152 StringMap<int> Names2TargetIndices;
Alex Lorenz49873a82015-08-06 00:44:07 +0000153 /// Maps from direct target flag names to the direct target flag values.
154 StringMap<unsigned> Names2DirectTargetFlags;
Alex Lorenzf3630112015-08-18 22:52:15 +0000155 /// Maps from direct target flag names to the bitmask target flag values.
156 StringMap<unsigned> Names2BitmaskTargetFlags;
Geoff Berry6748abe2017-07-13 02:28:54 +0000157 /// Maps from MMO target flag names to MMO target flag values.
158 StringMap<MachineMemOperand::Flags> Names2MMOTargetFlags;
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000159
160public:
Matthias Braun74ad41c2016-10-11 03:13:01 +0000161 MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
Matthias Braune35861d2016-07-13 23:27:50 +0000162 StringRef Source);
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000163
Quentin Colombet287c6bb2016-03-08 00:57:31 +0000164 /// \p SkipChar gives the number of characters to skip before looking
165 /// for the next token.
166 void lex(unsigned SkipChar = 0);
Alex Lorenz91370c52015-06-22 20:37:46 +0000167
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000168 /// Report an error at the current location with the given message.
169 ///
170 /// This function always return true.
171 bool error(const Twine &Msg);
172
Alex Lorenz91370c52015-06-22 20:37:46 +0000173 /// Report an error at the given location with the given message.
174 ///
175 /// This function always return true.
176 bool error(StringRef::iterator Loc, const Twine &Msg);
177
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000178 bool
179 parseBasicBlockDefinitions(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
180 bool parseBasicBlocks();
Alex Lorenz3708a642015-06-30 17:47:50 +0000181 bool parse(MachineInstr *&MI);
Alex Lorenz1ea60892015-07-27 20:29:27 +0000182 bool parseStandaloneMBB(MachineBasicBlock *&MBB);
183 bool parseStandaloneNamedRegister(unsigned &Reg);
Matthias Braun74ad41c2016-10-11 03:13:01 +0000184 bool parseStandaloneVirtualRegister(VRegInfo *&Info);
Tom Stellard9c884e42016-11-15 00:03:14 +0000185 bool parseStandaloneRegister(unsigned &Reg);
Alex Lorenza314d812015-08-18 22:26:26 +0000186 bool parseStandaloneStackObject(int &FI);
Alex Lorenzdf9e3c62015-08-19 00:13:25 +0000187 bool parseStandaloneMDNode(MDNode *&Node);
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000188
189 bool
190 parseBasicBlockDefinition(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
Matthias Braun89401142017-05-05 21:09:30 +0000191 bool parseBasicBlock(MachineBasicBlock &MBB,
192 MachineBasicBlock *&AddFalthroughFrom);
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000193 bool parseBasicBlockLiveins(MachineBasicBlock &MBB);
194 bool parseBasicBlockSuccessors(MachineBasicBlock &MBB);
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000195
Matthias Braun74ad41c2016-10-11 03:13:01 +0000196 bool parseNamedRegister(unsigned &Reg);
197 bool parseVirtualRegister(VRegInfo *&Info);
Puyan Lotfi399b46c2018-03-30 18:15:54 +0000198 bool parseNamedVirtualRegister(VRegInfo *&Info);
Matthias Braun74ad41c2016-10-11 03:13:01 +0000199 bool parseRegister(unsigned &Reg, VRegInfo *&VRegInfo);
Alex Lorenzcb268d42015-07-06 23:07:26 +0000200 bool parseRegisterFlag(unsigned &Flags);
Matthias Braunde5fea22017-01-18 00:59:19 +0000201 bool parseRegisterClassOrBank(VRegInfo &RegInfo);
Alex Lorenz2eacca82015-07-13 23:24:34 +0000202 bool parseSubRegisterIndex(unsigned &SubReg);
Alex Lorenz5ef93b02015-08-19 19:05:34 +0000203 bool parseRegisterTiedDefIndex(unsigned &TiedDefIdx);
204 bool parseRegisterOperand(MachineOperand &Dest,
205 Optional<unsigned> &TiedDefIdx, bool IsDef = false);
Alex Lorenz240fc1e2015-06-23 23:42:28 +0000206 bool parseImmediateOperand(MachineOperand &Dest);
Fangrui Songcb0bab82018-07-16 18:51:40 +0000207 bool parseIRConstant(StringRef::iterator Loc, StringRef StringValue,
Alex Lorenz5d8b0bd2015-08-21 21:48:22 +0000208 const Constant *&C);
Alex Lorenz7eaff4c2015-08-05 18:44:00 +0000209 bool parseIRConstant(StringRef::iterator Loc, const Constant *&C);
Ahmed Bougachad760de02016-07-28 17:15:12 +0000210 bool parseLowLevelType(StringRef::iterator Loc, LLT &Ty);
Alex Lorenz05e38822015-08-05 18:52:21 +0000211 bool parseTypedImmediateOperand(MachineOperand &Dest);
Alex Lorenzad156fb2015-07-31 20:49:21 +0000212 bool parseFPImmediateOperand(MachineOperand &Dest);
Alex Lorenzf09df002015-06-30 18:16:42 +0000213 bool parseMBBReference(MachineBasicBlock *&MBB);
Alex Lorenz33f0aef2015-06-26 16:46:11 +0000214 bool parseMBBOperand(MachineOperand &Dest);
Alex Lorenzdc9dadf2015-08-18 22:18:52 +0000215 bool parseStackFrameIndex(int &FI);
Alex Lorenz7feaf7c2015-07-16 23:37:45 +0000216 bool parseStackObjectOperand(MachineOperand &Dest);
Alex Lorenzea882122015-08-12 21:17:02 +0000217 bool parseFixedStackFrameIndex(int &FI);
Alex Lorenz7feaf7c2015-07-16 23:37:45 +0000218 bool parseFixedStackObjectOperand(MachineOperand &Dest);
Alex Lorenz41df7d32015-07-28 17:09:52 +0000219 bool parseGlobalValue(GlobalValue *&GV);
Alex Lorenz5d6108e2015-06-26 22:56:48 +0000220 bool parseGlobalAddressOperand(MachineOperand &Dest);
Alex Lorenzab980492015-07-20 20:51:18 +0000221 bool parseConstantPoolIndexOperand(MachineOperand &Dest);
Matthias Braunb74eb412016-03-28 18:18:46 +0000222 bool parseSubRegisterIndexOperand(MachineOperand &Dest);
Alex Lorenz31d70682015-07-15 23:38:35 +0000223 bool parseJumpTableIndexOperand(MachineOperand &Dest);
Alex Lorenz6ede3742015-07-21 16:59:53 +0000224 bool parseExternalSymbolOperand(MachineOperand &Dest);
Chandler Carruth75ca6be2018-08-16 23:11:05 +0000225 bool parseMCSymbolOperand(MachineOperand &Dest);
Alex Lorenz44f29252015-07-22 21:07:04 +0000226 bool parseMDNode(MDNode *&Node);
Fangrui Songcb0bab82018-07-16 18:51:40 +0000227 bool parseDIExpression(MDNode *&Expr);
Daniel Sanders9f3cf552018-12-13 14:25:27 +0000228 bool parseDILocation(MDNode *&Expr);
Alex Lorenz35e44462015-07-22 17:58:46 +0000229 bool parseMetadataOperand(MachineOperand &Dest);
Alex Lorenzf4baeb52015-07-21 22:28:27 +0000230 bool parseCFIOffset(int &Offset);
Alex Lorenz8cfc6862015-07-23 23:09:07 +0000231 bool parseCFIRegister(unsigned &Reg);
Francis Visoiu Mistrih5de20e02017-12-15 15:17:18 +0000232 bool parseCFIEscapeValues(std::string& Values);
Alex Lorenzf4baeb52015-07-21 22:28:27 +0000233 bool parseCFIOperand(MachineOperand &Dest);
Alex Lorenzdeb53492015-07-28 17:28:03 +0000234 bool parseIRBlock(BasicBlock *&BB, const Function &F);
235 bool parseBlockAddressOperand(MachineOperand &Dest);
Tim Northover6b3bd612016-07-29 20:32:59 +0000236 bool parseIntrinsicOperand(MachineOperand &Dest);
Tim Northoverde3aea0412016-08-17 20:25:25 +0000237 bool parsePredicateOperand(MachineOperand &Dest);
Alex Lorenzef5c1962015-07-28 23:02:45 +0000238 bool parseTargetIndexOperand(MachineOperand &Dest);
Oren Ben Simhon0ef61ec2017-03-19 08:14:18 +0000239 bool parseCustomRegisterMaskOperand(MachineOperand &Dest);
Alex Lorenzb97c9ef2015-08-10 23:24:42 +0000240 bool parseLiveoutRegisterMaskOperand(MachineOperand &Dest);
Alex Lorenz5ef93b02015-08-19 19:05:34 +0000241 bool parseMachineOperand(MachineOperand &Dest,
242 Optional<unsigned> &TiedDefIdx);
243 bool parseMachineOperandAndTargetFlags(MachineOperand &Dest,
244 Optional<unsigned> &TiedDefIdx);
Alex Lorenzdc24c172015-08-07 20:21:00 +0000245 bool parseOffset(int64_t &Offset);
Alex Lorenz620f8912015-08-13 20:33:33 +0000246 bool parseAlignment(unsigned &Alignment);
Francis Visoiu Mistrihe4718e82018-01-26 11:47:28 +0000247 bool parseAddrspace(unsigned &Addrspace);
Alex Lorenz5672a892015-08-05 22:26:15 +0000248 bool parseOperandsOffset(MachineOperand &Op);
Alex Lorenz36593ac2015-08-19 23:27:07 +0000249 bool parseIRValue(const Value *&V);
Justin Lebar0af80cd2016-07-15 18:26:59 +0000250 bool parseMemoryOperandFlag(MachineMemOperand::Flags &Flags);
Alex Lorenz91097a32015-08-12 20:33:26 +0000251 bool parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV);
252 bool parseMachinePointerInfo(MachinePointerInfo &Dest);
Konstantin Zhuravlyovbb80d3e2017-07-11 22:23:00 +0000253 bool parseOptionalScope(LLVMContext &Context, SyncScope::ID &SSID);
Tim Northoverb73e3092017-02-13 22:14:08 +0000254 bool parseOptionalAtomicOrdering(AtomicOrdering &Order);
Alex Lorenz4af7e612015-08-03 23:08:19 +0000255 bool parseMachineMemoryOperand(MachineMemOperand *&Dest);
Chandler Carruth75ca6be2018-08-16 23:11:05 +0000256 bool parsePreOrPostInstrSymbol(MCSymbol *&Symbol);
Alex Lorenzf3db51de2015-06-23 16:35:26 +0000257
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000258private:
Alex Lorenz33f0aef2015-06-26 16:46:11 +0000259 /// Convert the integer literal in the current token into an unsigned integer.
260 ///
261 /// Return true if an error occurred.
262 bool getUnsigned(unsigned &Result);
263
Alex Lorenz4af7e612015-08-03 23:08:19 +0000264 /// Convert the integer literal in the current token into an uint64.
265 ///
266 /// Return true if an error occurred.
267 bool getUint64(uint64_t &Result);
268
Krzysztof Parzyszek36ef5dc2016-12-16 13:58:01 +0000269 /// Convert the hexadecimal literal in the current token into an unsigned
270 /// APInt with a minimum bitwidth required to represent the value.
271 ///
272 /// Return true if the literal does not represent an integer value.
273 bool getHexUint(APInt &Result);
274
Alex Lorenz8cfc6862015-07-23 23:09:07 +0000275 /// If the current token is of the given kind, consume it and return false.
276 /// Otherwise report an error and return true.
277 bool expectAndConsume(MIToken::TokenKind TokenKind);
278
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000279 /// If the current token is of the given kind, consume it and return true.
280 /// Otherwise return false.
281 bool consumeIfPresent(MIToken::TokenKind TokenKind);
282
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000283 void initNames2InstrOpCodes();
284
285 /// Try to convert an instruction name to an opcode. Return true if the
286 /// instruction name is invalid.
287 bool parseInstrName(StringRef InstrName, unsigned &OpCode);
Alex Lorenz91370c52015-06-22 20:37:46 +0000288
Alex Lorenze5a44662015-07-17 00:24:15 +0000289 bool parseInstruction(unsigned &OpCode, unsigned &Flags);
Alex Lorenzf3db51de2015-06-23 16:35:26 +0000290
Alex Lorenz5ef93b02015-08-19 19:05:34 +0000291 bool assignRegisterTies(MachineInstr &MI,
Alex Lorenzfeb6b432015-08-19 19:19:16 +0000292 ArrayRef<ParsedMachineOperand> Operands);
Alex Lorenz5ef93b02015-08-19 19:05:34 +0000293
Alex Lorenzfeb6b432015-08-19 19:19:16 +0000294 bool verifyImplicitOperands(ArrayRef<ParsedMachineOperand> Operands,
Alex Lorenz36962cd2015-07-07 02:08:46 +0000295 const MCInstrDesc &MCID);
296
Alex Lorenzf3db51de2015-06-23 16:35:26 +0000297 void initNames2Regs();
298
299 /// Try to convert a register name to a register number. Return true if the
300 /// register name is invalid.
301 bool getRegisterByName(StringRef RegName, unsigned &Reg);
Alex Lorenz8f6f4282015-06-29 16:57:06 +0000302
303 void initNames2RegMasks();
304
305 /// Check if the given identifier is a name of a register mask.
306 ///
307 /// Return null if the identifier isn't a register mask.
308 const uint32_t *getRegMask(StringRef Identifier);
Alex Lorenz2eacca82015-07-13 23:24:34 +0000309
310 void initNames2SubRegIndices();
311
312 /// Check if the given identifier is a name of a subregister index.
313 ///
314 /// Return 0 if the name isn't a subregister index class.
315 unsigned getSubRegIndex(StringRef Name);
Alex Lorenz8a1915b2015-07-27 22:42:41 +0000316
Alex Lorenz8a1915b2015-07-27 22:42:41 +0000317 const BasicBlock *getIRBlock(unsigned Slot);
Alex Lorenzcba8c5f2015-08-06 23:57:04 +0000318 const BasicBlock *getIRBlock(unsigned Slot, const Function &F);
Alex Lorenzef5c1962015-07-28 23:02:45 +0000319
Alex Lorenzdd13be02015-08-19 23:31:05 +0000320 const Value *getIRValue(unsigned Slot);
321
Alex Lorenzef5c1962015-07-28 23:02:45 +0000322 void initNames2TargetIndices();
323
324 /// Try to convert a name of target index to the corresponding target index.
325 ///
326 /// Return true if the name isn't a name of a target index.
327 bool getTargetIndex(StringRef Name, int &Index);
Alex Lorenz49873a82015-08-06 00:44:07 +0000328
329 void initNames2DirectTargetFlags();
330
331 /// Try to convert a name of a direct target flag to the corresponding
332 /// target flag.
333 ///
334 /// Return true if the name isn't a name of a direct flag.
335 bool getDirectTargetFlag(StringRef Name, unsigned &Flag);
Alex Lorenzf3630112015-08-18 22:52:15 +0000336
337 void initNames2BitmaskTargetFlags();
338
339 /// Try to convert a name of a bitmask target flag to the corresponding
340 /// target flag.
341 ///
342 /// Return true if the name isn't a name of a bitmask target flag.
343 bool getBitmaskTargetFlag(StringRef Name, unsigned &Flag);
Konstantin Zhuravlyovbb80d3e2017-07-11 22:23:00 +0000344
Geoff Berry6748abe2017-07-13 02:28:54 +0000345 void initNames2MMOTargetFlags();
346
347 /// Try to convert a name of a MachineMemOperand target flag to the
348 /// corresponding target flag.
349 ///
350 /// Return true if the name isn't a name of a target MMO flag.
351 bool getMMOTargetFlag(StringRef Name, MachineMemOperand::Flags &Flag);
352
Chandler Carruth75ca6be2018-08-16 23:11:05 +0000353 /// Get or create an MCSymbol for a given name.
354 MCSymbol *getOrCreateMCSymbol(StringRef Name);
355
Konstantin Zhuravlyovbb80d3e2017-07-11 22:23:00 +0000356 /// parseStringConstant
357 /// ::= StringConstant
358 bool parseStringConstant(std::string &Result);
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000359};
360
361} // end anonymous namespace
362
Matthias Braun74ad41c2016-10-11 03:13:01 +0000363MIParser::MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
Matthias Braune35861d2016-07-13 23:27:50 +0000364 StringRef Source)
365 : MF(PFS.MF), Error(Error), Source(Source), CurrentSource(Source), PFS(PFS)
366{}
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000367
Quentin Colombet287c6bb2016-03-08 00:57:31 +0000368void MIParser::lex(unsigned SkipChar) {
Alex Lorenz91370c52015-06-22 20:37:46 +0000369 CurrentSource = lexMIToken(
Quentin Colombet287c6bb2016-03-08 00:57:31 +0000370 CurrentSource.data() + SkipChar, Token,
Alex Lorenz91370c52015-06-22 20:37:46 +0000371 [this](StringRef::iterator Loc, const Twine &Msg) { error(Loc, Msg); });
372}
373
374bool MIParser::error(const Twine &Msg) { return error(Token.location(), Msg); }
375
376bool MIParser::error(StringRef::iterator Loc, const Twine &Msg) {
Matthias Braune35861d2016-07-13 23:27:50 +0000377 const SourceMgr &SM = *PFS.SM;
Alex Lorenz91370c52015-06-22 20:37:46 +0000378 assert(Loc >= Source.data() && Loc <= (Source.data() + Source.size()));
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000379 const MemoryBuffer &Buffer = *SM.getMemoryBuffer(SM.getMainFileID());
380 if (Loc >= Buffer.getBufferStart() && Loc <= Buffer.getBufferEnd()) {
381 // Create an ordinary diagnostic when the source manager's buffer is the
382 // source string.
383 Error = SM.GetMessage(SMLoc::getFromPointer(Loc), SourceMgr::DK_Error, Msg);
384 return true;
385 }
386 // Create a diagnostic for a YAML string literal.
387 Error = SMDiagnostic(SM, SMLoc(), Buffer.getBufferIdentifier(), 1,
388 Loc - Source.data(), SourceMgr::DK_Error, Msg.str(),
389 Source, None, None);
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000390 return true;
391}
392
Alex Lorenz8cfc6862015-07-23 23:09:07 +0000393static const char *toString(MIToken::TokenKind TokenKind) {
394 switch (TokenKind) {
395 case MIToken::comma:
396 return "','";
Alex Lorenzfbe9c042015-07-29 18:51:21 +0000397 case MIToken::equal:
398 return "'='";
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000399 case MIToken::colon:
400 return "':'";
Alex Lorenzdeb53492015-07-28 17:28:03 +0000401 case MIToken::lparen:
402 return "'('";
403 case MIToken::rparen:
404 return "')'";
Alex Lorenz8cfc6862015-07-23 23:09:07 +0000405 default:
406 return "<unknown token>";
407 }
408}
409
410bool MIParser::expectAndConsume(MIToken::TokenKind TokenKind) {
411 if (Token.isNot(TokenKind))
412 return error(Twine("expected ") + toString(TokenKind));
413 lex();
414 return false;
415}
416
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000417bool MIParser::consumeIfPresent(MIToken::TokenKind TokenKind) {
418 if (Token.isNot(TokenKind))
419 return false;
Alex Lorenz91370c52015-06-22 20:37:46 +0000420 lex();
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000421 return true;
422}
Alex Lorenz91370c52015-06-22 20:37:46 +0000423
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000424bool MIParser::parseBasicBlockDefinition(
425 DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
426 assert(Token.is(MIToken::MachineBasicBlockLabel));
427 unsigned ID = 0;
428 if (getUnsigned(ID))
429 return true;
430 auto Loc = Token.location();
431 auto Name = Token.stringValue();
432 lex();
433 bool HasAddressTaken = false;
434 bool IsLandingPad = false;
435 unsigned Alignment = 0;
436 BasicBlock *BB = nullptr;
437 if (consumeIfPresent(MIToken::lparen)) {
438 do {
439 // TODO: Report an error when multiple same attributes are specified.
440 switch (Token.kind()) {
441 case MIToken::kw_address_taken:
442 HasAddressTaken = true;
443 lex();
444 break;
445 case MIToken::kw_landing_pad:
446 IsLandingPad = true;
447 lex();
448 break;
449 case MIToken::kw_align:
450 if (parseAlignment(Alignment))
451 return true;
452 break;
453 case MIToken::IRBlock:
454 // TODO: Report an error when both name and ir block are specified.
Matthias Braunf1caa282017-12-15 22:22:58 +0000455 if (parseIRBlock(BB, MF.getFunction()))
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000456 return true;
457 lex();
458 break;
459 default:
460 break;
461 }
462 } while (consumeIfPresent(MIToken::comma));
463 if (expectAndConsume(MIToken::rparen))
464 return true;
465 }
466 if (expectAndConsume(MIToken::colon))
467 return true;
468
469 if (!Name.empty()) {
470 BB = dyn_cast_or_null<BasicBlock>(
Matthias Braunf1caa282017-12-15 22:22:58 +0000471 MF.getFunction().getValueSymbolTable()->lookup(Name));
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000472 if (!BB)
473 return error(Loc, Twine("basic block '") + Name +
474 "' is not defined in the function '" +
475 MF.getName() + "'");
476 }
477 auto *MBB = MF.CreateMachineBasicBlock(BB);
478 MF.insert(MF.end(), MBB);
479 bool WasInserted = MBBSlots.insert(std::make_pair(ID, MBB)).second;
480 if (!WasInserted)
481 return error(Loc, Twine("redefinition of machine basic block with id #") +
482 Twine(ID));
483 if (Alignment)
484 MBB->setAlignment(Alignment);
485 if (HasAddressTaken)
486 MBB->setHasAddressTaken();
Reid Kleckner0e288232015-08-27 23:27:47 +0000487 MBB->setIsEHPad(IsLandingPad);
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000488 return false;
489}
490
491bool MIParser::parseBasicBlockDefinitions(
492 DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
493 lex();
494 // Skip until the first machine basic block.
495 while (Token.is(MIToken::Newline))
496 lex();
497 if (Token.isErrorOrEOF())
498 return Token.isError();
499 if (Token.isNot(MIToken::MachineBasicBlockLabel))
500 return error("expected a basic block definition before instructions");
Alex Lorenzf9a2b122015-08-14 18:57:24 +0000501 unsigned BraceDepth = 0;
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000502 do {
503 if (parseBasicBlockDefinition(MBBSlots))
504 return true;
505 bool IsAfterNewline = false;
506 // Skip until the next machine basic block.
507 while (true) {
508 if ((Token.is(MIToken::MachineBasicBlockLabel) && IsAfterNewline) ||
509 Token.isErrorOrEOF())
510 break;
511 else if (Token.is(MIToken::MachineBasicBlockLabel))
512 return error("basic block definition should be located at the start of "
513 "the line");
Alex Lorenzf9a2b122015-08-14 18:57:24 +0000514 else if (consumeIfPresent(MIToken::Newline)) {
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000515 IsAfterNewline = true;
Alex Lorenzf9a2b122015-08-14 18:57:24 +0000516 continue;
517 }
518 IsAfterNewline = false;
519 if (Token.is(MIToken::lbrace))
520 ++BraceDepth;
521 if (Token.is(MIToken::rbrace)) {
522 if (!BraceDepth)
523 return error("extraneous closing brace ('}')");
524 --BraceDepth;
525 }
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000526 lex();
527 }
Alex Lorenzf9a2b122015-08-14 18:57:24 +0000528 // Verify that we closed all of the '{' at the end of a file or a block.
529 if (!Token.isError() && BraceDepth)
530 return error("expected '}'"); // FIXME: Report a note that shows '{'.
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000531 } while (!Token.isErrorOrEOF());
532 return Token.isError();
533}
534
535bool MIParser::parseBasicBlockLiveins(MachineBasicBlock &MBB) {
536 assert(Token.is(MIToken::kw_liveins));
537 lex();
538 if (expectAndConsume(MIToken::colon))
539 return true;
540 if (Token.isNewlineOrEOF()) // Allow an empty list of liveins.
541 return false;
542 do {
543 if (Token.isNot(MIToken::NamedRegister))
544 return error("expected a named register");
545 unsigned Reg = 0;
Matthias Braun74ad41c2016-10-11 03:13:01 +0000546 if (parseNamedRegister(Reg))
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000547 return true;
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000548 lex();
Krzysztof Parzyszek91b5cf82016-12-15 14:36:06 +0000549 LaneBitmask Mask = LaneBitmask::getAll();
Krzysztof Parzyszekd62669d2016-10-12 21:06:45 +0000550 if (consumeIfPresent(MIToken::colon)) {
551 // Parse lane mask.
552 if (Token.isNot(MIToken::IntegerLiteral) &&
553 Token.isNot(MIToken::HexLiteral))
554 return error("expected a lane mask");
Krzysztof Parzyszek91b5cf82016-12-15 14:36:06 +0000555 static_assert(sizeof(LaneBitmask::Type) == sizeof(unsigned),
556 "Use correct get-function for lane mask");
557 LaneBitmask::Type V;
558 if (getUnsigned(V))
Krzysztof Parzyszekd62669d2016-10-12 21:06:45 +0000559 return error("invalid lane mask value");
Krzysztof Parzyszek91b5cf82016-12-15 14:36:06 +0000560 Mask = LaneBitmask(V);
Krzysztof Parzyszekd62669d2016-10-12 21:06:45 +0000561 lex();
562 }
563 MBB.addLiveIn(Reg, Mask);
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000564 } while (consumeIfPresent(MIToken::comma));
565 return false;
566}
567
568bool MIParser::parseBasicBlockSuccessors(MachineBasicBlock &MBB) {
569 assert(Token.is(MIToken::kw_successors));
570 lex();
571 if (expectAndConsume(MIToken::colon))
572 return true;
573 if (Token.isNewlineOrEOF()) // Allow an empty list of successors.
574 return false;
575 do {
576 if (Token.isNot(MIToken::MachineBasicBlock))
577 return error("expected a machine basic block reference");
578 MachineBasicBlock *SuccMBB = nullptr;
579 if (parseMBBReference(SuccMBB))
580 return true;
581 lex();
582 unsigned Weight = 0;
583 if (consumeIfPresent(MIToken::lparen)) {
Geoff Berryb51774a2016-11-18 19:37:24 +0000584 if (Token.isNot(MIToken::IntegerLiteral) &&
585 Token.isNot(MIToken::HexLiteral))
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000586 return error("expected an integer literal after '('");
587 if (getUnsigned(Weight))
588 return true;
589 lex();
590 if (expectAndConsume(MIToken::rparen))
591 return true;
592 }
Cong Houd97c1002015-12-01 05:29:22 +0000593 MBB.addSuccessor(SuccMBB, BranchProbability::getRaw(Weight));
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000594 } while (consumeIfPresent(MIToken::comma));
Cong Houd97c1002015-12-01 05:29:22 +0000595 MBB.normalizeSuccProbs();
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000596 return false;
597}
598
Matthias Braun89401142017-05-05 21:09:30 +0000599bool MIParser::parseBasicBlock(MachineBasicBlock &MBB,
600 MachineBasicBlock *&AddFalthroughFrom) {
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000601 // Skip the definition.
602 assert(Token.is(MIToken::MachineBasicBlockLabel));
603 lex();
604 if (consumeIfPresent(MIToken::lparen)) {
605 while (Token.isNot(MIToken::rparen) && !Token.isErrorOrEOF())
606 lex();
607 consumeIfPresent(MIToken::rparen);
608 }
609 consumeIfPresent(MIToken::colon);
610
611 // Parse the liveins and successors.
612 // N.B: Multiple lists of successors and liveins are allowed and they're
613 // merged into one.
614 // Example:
615 // liveins: %edi
616 // liveins: %esi
617 //
618 // is equivalent to
619 // liveins: %edi, %esi
Hiroshi Inoue6a391bb2017-06-27 10:35:37 +0000620 bool ExplicitSuccessors = false;
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000621 while (true) {
622 if (Token.is(MIToken::kw_successors)) {
623 if (parseBasicBlockSuccessors(MBB))
624 return true;
Hiroshi Inoue6a391bb2017-06-27 10:35:37 +0000625 ExplicitSuccessors = true;
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000626 } else if (Token.is(MIToken::kw_liveins)) {
627 if (parseBasicBlockLiveins(MBB))
628 return true;
629 } else if (consumeIfPresent(MIToken::Newline)) {
630 continue;
631 } else
632 break;
633 if (!Token.isNewlineOrEOF())
634 return error("expected line break at the end of a list");
635 lex();
636 }
637
638 // Parse the instructions.
Alex Lorenzf9a2b122015-08-14 18:57:24 +0000639 bool IsInBundle = false;
640 MachineInstr *PrevMI = nullptr;
Matthias Braun89401142017-05-05 21:09:30 +0000641 while (!Token.is(MIToken::MachineBasicBlockLabel) &&
642 !Token.is(MIToken::Eof)) {
643 if (consumeIfPresent(MIToken::Newline))
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000644 continue;
Alex Lorenzf9a2b122015-08-14 18:57:24 +0000645 if (consumeIfPresent(MIToken::rbrace)) {
646 // The first parsing pass should verify that all closing '}' have an
647 // opening '{'.
648 assert(IsInBundle);
649 IsInBundle = false;
650 continue;
651 }
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000652 MachineInstr *MI = nullptr;
653 if (parse(MI))
654 return true;
655 MBB.insert(MBB.end(), MI);
Alex Lorenzf9a2b122015-08-14 18:57:24 +0000656 if (IsInBundle) {
657 PrevMI->setFlag(MachineInstr::BundledSucc);
658 MI->setFlag(MachineInstr::BundledPred);
659 }
660 PrevMI = MI;
661 if (Token.is(MIToken::lbrace)) {
662 if (IsInBundle)
663 return error("nested instruction bundles are not allowed");
664 lex();
665 // This instruction is the start of the bundle.
666 MI->setFlag(MachineInstr::BundledSucc);
667 IsInBundle = true;
668 if (!Token.is(MIToken::Newline))
669 // The next instruction can be on the same line.
670 continue;
671 }
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000672 assert(Token.isNewlineOrEOF() && "MI is not fully parsed");
673 lex();
674 }
Matthias Braun89401142017-05-05 21:09:30 +0000675
676 // Construct successor list by searching for basic block machine operands.
Hiroshi Inoue6a391bb2017-06-27 10:35:37 +0000677 if (!ExplicitSuccessors) {
Matthias Braun89401142017-05-05 21:09:30 +0000678 SmallVector<MachineBasicBlock*,4> Successors;
679 bool IsFallthrough;
680 guessSuccessors(MBB, Successors, IsFallthrough);
681 for (MachineBasicBlock *Succ : Successors)
682 MBB.addSuccessor(Succ);
683
684 if (IsFallthrough) {
685 AddFalthroughFrom = &MBB;
686 } else {
687 MBB.normalizeSuccProbs();
688 }
689 }
690
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000691 return false;
692}
693
694bool MIParser::parseBasicBlocks() {
695 lex();
696 // Skip until the first machine basic block.
697 while (Token.is(MIToken::Newline))
698 lex();
699 if (Token.isErrorOrEOF())
700 return Token.isError();
701 // The first parsing pass should have verified that this token is a MBB label
702 // in the 'parseBasicBlockDefinitions' method.
703 assert(Token.is(MIToken::MachineBasicBlockLabel));
Matthias Braun89401142017-05-05 21:09:30 +0000704 MachineBasicBlock *AddFalthroughFrom = nullptr;
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000705 do {
706 MachineBasicBlock *MBB = nullptr;
707 if (parseMBBReference(MBB))
708 return true;
Matthias Braun89401142017-05-05 21:09:30 +0000709 if (AddFalthroughFrom) {
710 if (!AddFalthroughFrom->isSuccessor(MBB))
711 AddFalthroughFrom->addSuccessor(MBB);
712 AddFalthroughFrom->normalizeSuccProbs();
713 AddFalthroughFrom = nullptr;
714 }
715 if (parseBasicBlock(*MBB, AddFalthroughFrom))
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000716 return true;
717 // The method 'parseBasicBlock' should parse the whole block until the next
718 // block or the end of file.
719 assert(Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof));
720 } while (Token.isNot(MIToken::Eof));
721 return false;
722}
723
724bool MIParser::parse(MachineInstr *&MI) {
Alex Lorenzf3db51de2015-06-23 16:35:26 +0000725 // Parse any register operands before '='
Alex Lorenzf3db51de2015-06-23 16:35:26 +0000726 MachineOperand MO = MachineOperand::CreateImm(0);
Alex Lorenzfeb6b432015-08-19 19:19:16 +0000727 SmallVector<ParsedMachineOperand, 8> Operands;
Alex Lorenzfbe9c042015-07-29 18:51:21 +0000728 while (Token.isRegister() || Token.isRegisterFlag()) {
Alex Lorenz36962cd2015-07-07 02:08:46 +0000729 auto Loc = Token.location();
Alex Lorenz5ef93b02015-08-19 19:05:34 +0000730 Optional<unsigned> TiedDefIdx;
731 if (parseRegisterOperand(MO, TiedDefIdx, /*IsDef=*/true))
Alex Lorenz3708a642015-06-30 17:47:50 +0000732 return true;
Alex Lorenz5ef93b02015-08-19 19:05:34 +0000733 Operands.push_back(
Alex Lorenzfeb6b432015-08-19 19:19:16 +0000734 ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
Alex Lorenzfbe9c042015-07-29 18:51:21 +0000735 if (Token.isNot(MIToken::comma))
736 break;
Alex Lorenzf3db51de2015-06-23 16:35:26 +0000737 lex();
738 }
Alex Lorenzfbe9c042015-07-29 18:51:21 +0000739 if (!Operands.empty() && expectAndConsume(MIToken::equal))
740 return true;
Alex Lorenzf3db51de2015-06-23 16:35:26 +0000741
Alex Lorenze5a44662015-07-17 00:24:15 +0000742 unsigned OpCode, Flags = 0;
743 if (Token.isError() || parseInstruction(OpCode, Flags))
Alex Lorenz3708a642015-06-30 17:47:50 +0000744 return true;
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000745
Alex Lorenzf3db51de2015-06-23 16:35:26 +0000746 // Parse the remaining machine operands.
Chandler Carruth75ca6be2018-08-16 23:11:05 +0000747 while (!Token.isNewlineOrEOF() && Token.isNot(MIToken::kw_pre_instr_symbol) &&
748 Token.isNot(MIToken::kw_post_instr_symbol) &&
749 Token.isNot(MIToken::kw_debug_location) &&
Alex Lorenzf9a2b122015-08-14 18:57:24 +0000750 Token.isNot(MIToken::coloncolon) && Token.isNot(MIToken::lbrace)) {
Alex Lorenz36962cd2015-07-07 02:08:46 +0000751 auto Loc = Token.location();
Alex Lorenz5ef93b02015-08-19 19:05:34 +0000752 Optional<unsigned> TiedDefIdx;
753 if (parseMachineOperandAndTargetFlags(MO, TiedDefIdx))
Alex Lorenz3708a642015-06-30 17:47:50 +0000754 return true;
Matthias Brauna8340382018-10-30 23:28:27 +0000755 if (OpCode == TargetOpcode::DBG_VALUE && MO.isReg())
756 MO.setIsDebug();
Alex Lorenz5ef93b02015-08-19 19:05:34 +0000757 Operands.push_back(
Alex Lorenzfeb6b432015-08-19 19:19:16 +0000758 ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
Alex Lorenzf9a2b122015-08-14 18:57:24 +0000759 if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
760 Token.is(MIToken::lbrace))
Alex Lorenzf3db51de2015-06-23 16:35:26 +0000761 break;
Alex Lorenz3708a642015-06-30 17:47:50 +0000762 if (Token.isNot(MIToken::comma))
763 return error("expected ',' before the next machine operand");
Alex Lorenzf3db51de2015-06-23 16:35:26 +0000764 lex();
765 }
766
Chandler Carruth75ca6be2018-08-16 23:11:05 +0000767 MCSymbol *PreInstrSymbol = nullptr;
768 if (Token.is(MIToken::kw_pre_instr_symbol))
769 if (parsePreOrPostInstrSymbol(PreInstrSymbol))
770 return true;
771 MCSymbol *PostInstrSymbol = nullptr;
772 if (Token.is(MIToken::kw_post_instr_symbol))
773 if (parsePreOrPostInstrSymbol(PostInstrSymbol))
774 return true;
775
Alex Lorenz46d760d2015-07-22 21:15:11 +0000776 DebugLoc DebugLocation;
777 if (Token.is(MIToken::kw_debug_location)) {
778 lex();
Alex Lorenz46d760d2015-07-22 21:15:11 +0000779 MDNode *Node = nullptr;
Daniel Sanders9f3cf552018-12-13 14:25:27 +0000780 if (Token.is(MIToken::exclaim)) {
781 if (parseMDNode(Node))
782 return true;
783 } else if (Token.is(MIToken::md_dilocation)) {
784 if (parseDILocation(Node))
785 return true;
786 } else
787 return error("expected a metadata node after 'debug-location'");
Matthias Braun7159daa2018-10-01 17:50:52 +0000788 if (!isa<DILocation>(Node))
789 return error("referenced metadata is not a DILocation");
Alex Lorenz46d760d2015-07-22 21:15:11 +0000790 DebugLocation = DebugLoc(Node);
791 }
792
Alex Lorenz4af7e612015-08-03 23:08:19 +0000793 // Parse the machine memory operands.
794 SmallVector<MachineMemOperand *, 2> MemOperands;
795 if (Token.is(MIToken::coloncolon)) {
796 lex();
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000797 while (!Token.isNewlineOrEOF()) {
Alex Lorenz4af7e612015-08-03 23:08:19 +0000798 MachineMemOperand *MemOp = nullptr;
799 if (parseMachineMemoryOperand(MemOp))
800 return true;
801 MemOperands.push_back(MemOp);
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000802 if (Token.isNewlineOrEOF())
Alex Lorenz4af7e612015-08-03 23:08:19 +0000803 break;
804 if (Token.isNot(MIToken::comma))
805 return error("expected ',' before the next machine memory operand");
806 lex();
807 }
808 }
809
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000810 const auto &MCID = MF.getSubtarget().getInstrInfo()->get(OpCode);
Alex Lorenz36962cd2015-07-07 02:08:46 +0000811 if (!MCID.isVariadic()) {
812 // FIXME: Move the implicit operand verification to the machine verifier.
813 if (verifyImplicitOperands(Operands, MCID))
814 return true;
815 }
Alex Lorenzf3db51de2015-06-23 16:35:26 +0000816
Alex Lorenzcb268d42015-07-06 23:07:26 +0000817 // TODO: Check for extraneous machine operands.
Alex Lorenz46d760d2015-07-22 21:15:11 +0000818 MI = MF.CreateMachineInstr(MCID, DebugLocation, /*NoImplicit=*/true);
Alex Lorenze5a44662015-07-17 00:24:15 +0000819 MI->setFlags(Flags);
Alex Lorenzf3db51de2015-06-23 16:35:26 +0000820 for (const auto &Operand : Operands)
Alex Lorenz36962cd2015-07-07 02:08:46 +0000821 MI->addOperand(MF, Operand.Operand);
Alex Lorenz5ef93b02015-08-19 19:05:34 +0000822 if (assignRegisterTies(*MI, Operands))
823 return true;
Chandler Carruth75ca6be2018-08-16 23:11:05 +0000824 if (PreInstrSymbol)
825 MI->setPreInstrSymbol(MF, PreInstrSymbol);
826 if (PostInstrSymbol)
827 MI->setPostInstrSymbol(MF, PostInstrSymbol);
828 if (!MemOperands.empty())
829 MI->setMemRefs(MF, MemOperands);
Alex Lorenz3708a642015-06-30 17:47:50 +0000830 return false;
Alex Lorenz8e0a1b42015-06-22 17:02:30 +0000831}
832
Alex Lorenz1ea60892015-07-27 20:29:27 +0000833bool MIParser::parseStandaloneMBB(MachineBasicBlock *&MBB) {
Alex Lorenzf09df002015-06-30 18:16:42 +0000834 lex();
835 if (Token.isNot(MIToken::MachineBasicBlock))
836 return error("expected a machine basic block reference");
837 if (parseMBBReference(MBB))
838 return true;
839 lex();
840 if (Token.isNot(MIToken::Eof))
841 return error(
842 "expected end of string after the machine basic block reference");
843 return false;
844}
845
Alex Lorenz1ea60892015-07-27 20:29:27 +0000846bool MIParser::parseStandaloneNamedRegister(unsigned &Reg) {
Alex Lorenz9fab3702015-07-14 21:24:41 +0000847 lex();
848 if (Token.isNot(MIToken::NamedRegister))
849 return error("expected a named register");
Matthias Braun74ad41c2016-10-11 03:13:01 +0000850 if (parseNamedRegister(Reg))
Alex Lorenz607efb62015-08-18 22:57:36 +0000851 return true;
Alex Lorenz9fab3702015-07-14 21:24:41 +0000852 lex();
853 if (Token.isNot(MIToken::Eof))
854 return error("expected end of string after the register reference");
855 return false;
856}
857
Matthias Braun74ad41c2016-10-11 03:13:01 +0000858bool MIParser::parseStandaloneVirtualRegister(VRegInfo *&Info) {
Alex Lorenz12045a42015-07-27 17:42:45 +0000859 lex();
860 if (Token.isNot(MIToken::VirtualRegister))
861 return error("expected a virtual register");
Matthias Braun74ad41c2016-10-11 03:13:01 +0000862 if (parseVirtualRegister(Info))
Alex Lorenz607efb62015-08-18 22:57:36 +0000863 return true;
Alex Lorenz12045a42015-07-27 17:42:45 +0000864 lex();
865 if (Token.isNot(MIToken::Eof))
866 return error("expected end of string after the register reference");
867 return false;
868}
869
Tom Stellard9c884e42016-11-15 00:03:14 +0000870bool MIParser::parseStandaloneRegister(unsigned &Reg) {
871 lex();
872 if (Token.isNot(MIToken::NamedRegister) &&
873 Token.isNot(MIToken::VirtualRegister))
874 return error("expected either a named or virtual register");
875
876 VRegInfo *Info;
877 if (parseRegister(Reg, Info))
878 return true;
879
880 lex();
881 if (Token.isNot(MIToken::Eof))
882 return error("expected end of string after the register reference");
883 return false;
884}
885
Alex Lorenza314d812015-08-18 22:26:26 +0000886bool MIParser::parseStandaloneStackObject(int &FI) {
887 lex();
888 if (Token.isNot(MIToken::StackObject))
889 return error("expected a stack object");
890 if (parseStackFrameIndex(FI))
891 return true;
892 if (Token.isNot(MIToken::Eof))
893 return error("expected end of string after the stack object reference");
894 return false;
895}
896
Alex Lorenzdf9e3c62015-08-19 00:13:25 +0000897bool MIParser::parseStandaloneMDNode(MDNode *&Node) {
898 lex();
Reid Kleckner6d353342017-08-23 20:31:27 +0000899 if (Token.is(MIToken::exclaim)) {
900 if (parseMDNode(Node))
901 return true;
902 } else if (Token.is(MIToken::md_diexpr)) {
903 if (parseDIExpression(Node))
904 return true;
Daniel Sanders9f3cf552018-12-13 14:25:27 +0000905 } else if (Token.is(MIToken::md_dilocation)) {
906 if (parseDILocation(Node))
907 return true;
Reid Kleckner6d353342017-08-23 20:31:27 +0000908 } else
Alex Lorenzdf9e3c62015-08-19 00:13:25 +0000909 return error("expected a metadata node");
Alex Lorenzdf9e3c62015-08-19 00:13:25 +0000910 if (Token.isNot(MIToken::Eof))
911 return error("expected end of string after the metadata node");
912 return false;
913}
914
Alex Lorenz36962cd2015-07-07 02:08:46 +0000915static const char *printImplicitRegisterFlag(const MachineOperand &MO) {
916 assert(MO.isImplicit());
917 return MO.isDef() ? "implicit-def" : "implicit";
918}
919
920static std::string getRegisterName(const TargetRegisterInfo *TRI,
921 unsigned Reg) {
922 assert(TargetRegisterInfo::isPhysicalRegister(Reg) && "expected phys reg");
923 return StringRef(TRI->getName(Reg)).lower();
924}
925
Alex Lorenz0153e592015-09-10 14:04:34 +0000926/// Return true if the parsed machine operands contain a given machine operand.
927static bool isImplicitOperandIn(const MachineOperand &ImplicitOperand,
928 ArrayRef<ParsedMachineOperand> Operands) {
929 for (const auto &I : Operands) {
930 if (ImplicitOperand.isIdenticalTo(I.Operand))
931 return true;
932 }
933 return false;
934}
935
Alex Lorenzfeb6b432015-08-19 19:19:16 +0000936bool MIParser::verifyImplicitOperands(ArrayRef<ParsedMachineOperand> Operands,
937 const MCInstrDesc &MCID) {
Alex Lorenz36962cd2015-07-07 02:08:46 +0000938 if (MCID.isCall())
939 // We can't verify call instructions as they can contain arbitrary implicit
940 // register and register mask operands.
941 return false;
942
943 // Gather all the expected implicit operands.
944 SmallVector<MachineOperand, 4> ImplicitOperands;
945 if (MCID.ImplicitDefs)
Craig Toppere5e035a32015-12-05 07:13:35 +0000946 for (const MCPhysReg *ImpDefs = MCID.getImplicitDefs(); *ImpDefs; ++ImpDefs)
Alex Lorenz36962cd2015-07-07 02:08:46 +0000947 ImplicitOperands.push_back(
948 MachineOperand::CreateReg(*ImpDefs, true, true));
949 if (MCID.ImplicitUses)
Craig Toppere5e035a32015-12-05 07:13:35 +0000950 for (const MCPhysReg *ImpUses = MCID.getImplicitUses(); *ImpUses; ++ImpUses)
Alex Lorenz36962cd2015-07-07 02:08:46 +0000951 ImplicitOperands.push_back(
952 MachineOperand::CreateReg(*ImpUses, false, true));
953
954 const auto *TRI = MF.getSubtarget().getRegisterInfo();
955 assert(TRI && "Expected target register info");
Alex Lorenz0153e592015-09-10 14:04:34 +0000956 for (const auto &I : ImplicitOperands) {
957 if (isImplicitOperandIn(I, Operands))
958 continue;
959 return error(Operands.empty() ? Token.location() : Operands.back().End,
Alex Lorenz36962cd2015-07-07 02:08:46 +0000960 Twine("missing implicit register operand '") +
Matt Davisa245c762018-06-19 18:39:40 +0000961 printImplicitRegisterFlag(I) + " $" +
Alex Lorenz0153e592015-09-10 14:04:34 +0000962 getRegisterName(TRI, I.getReg()) + "'");
Alex Lorenz36962cd2015-07-07 02:08:46 +0000963 }
964 return false;
965}
966
Alex Lorenze5a44662015-07-17 00:24:15 +0000967bool MIParser::parseInstruction(unsigned &OpCode, unsigned &Flags) {
Michael Berg7d1b25d2018-05-03 00:07:56 +0000968 // Allow frame and fast math flags for OPCODE
Francis Visoiu Mistrih3abf05732018-03-13 19:53:16 +0000969 while (Token.is(MIToken::kw_frame_setup) ||
Michael Berg7d1b25d2018-05-03 00:07:56 +0000970 Token.is(MIToken::kw_frame_destroy) ||
971 Token.is(MIToken::kw_nnan) ||
972 Token.is(MIToken::kw_ninf) ||
973 Token.is(MIToken::kw_nsz) ||
974 Token.is(MIToken::kw_arcp) ||
975 Token.is(MIToken::kw_contract) ||
976 Token.is(MIToken::kw_afn) ||
Michael Bergc72a7252018-09-11 21:35:32 +0000977 Token.is(MIToken::kw_reassoc) ||
978 Token.is(MIToken::kw_nuw) ||
979 Token.is(MIToken::kw_nsw) ||
980 Token.is(MIToken::kw_exact)) {
Michael Berg7d1b25d2018-05-03 00:07:56 +0000981 // Mine frame and fast math flags
982 if (Token.is(MIToken::kw_frame_setup))
983 Flags |= MachineInstr::FrameSetup;
984 if (Token.is(MIToken::kw_frame_destroy))
985 Flags |= MachineInstr::FrameDestroy;
986 if (Token.is(MIToken::kw_nnan))
987 Flags |= MachineInstr::FmNoNans;
988 if (Token.is(MIToken::kw_ninf))
989 Flags |= MachineInstr::FmNoInfs;
990 if (Token.is(MIToken::kw_nsz))
991 Flags |= MachineInstr::FmNsz;
992 if (Token.is(MIToken::kw_arcp))
993 Flags |= MachineInstr::FmArcp;
994 if (Token.is(MIToken::kw_contract))
995 Flags |= MachineInstr::FmContract;
996 if (Token.is(MIToken::kw_afn))
997 Flags |= MachineInstr::FmAfn;
998 if (Token.is(MIToken::kw_reassoc))
999 Flags |= MachineInstr::FmReassoc;
Michael Bergc72a7252018-09-11 21:35:32 +00001000 if (Token.is(MIToken::kw_nuw))
1001 Flags |= MachineInstr::NoUWrap;
1002 if (Token.is(MIToken::kw_nsw))
1003 Flags |= MachineInstr::NoSWrap;
1004 if (Token.is(MIToken::kw_exact))
1005 Flags |= MachineInstr::IsExact;
Michael Berg7d1b25d2018-05-03 00:07:56 +00001006
Francis Visoiu Mistrihdbf2c482018-01-09 11:33:22 +00001007 lex();
Alex Lorenze5a44662015-07-17 00:24:15 +00001008 }
Alex Lorenz91370c52015-06-22 20:37:46 +00001009 if (Token.isNot(MIToken::Identifier))
1010 return error("expected a machine instruction");
1011 StringRef InstrName = Token.stringValue();
1012 if (parseInstrName(InstrName, OpCode))
1013 return error(Twine("unknown machine instruction name '") + InstrName + "'");
Alex Lorenzf3db51de2015-06-23 16:35:26 +00001014 lex();
1015 return false;
1016}
1017
Matthias Braun74ad41c2016-10-11 03:13:01 +00001018bool MIParser::parseNamedRegister(unsigned &Reg) {
1019 assert(Token.is(MIToken::NamedRegister) && "Needs NamedRegister token");
1020 StringRef Name = Token.stringValue();
1021 if (getRegisterByName(Name, Reg))
1022 return error(Twine("unknown register name '") + Name + "'");
1023 return false;
1024}
1025
Puyan Lotfi399b46c2018-03-30 18:15:54 +00001026bool MIParser::parseNamedVirtualRegister(VRegInfo *&Info) {
1027 assert(Token.is(MIToken::NamedVirtualRegister) && "Expected NamedVReg token");
1028 StringRef Name = Token.stringValue();
1029 // TODO: Check that the VReg name is not the same as a physical register name.
1030 // If it is, then print a warning (when warnings are implemented).
1031 Info = &PFS.getVRegInfoNamed(Name);
1032 return false;
1033}
1034
Matthias Braun74ad41c2016-10-11 03:13:01 +00001035bool MIParser::parseVirtualRegister(VRegInfo *&Info) {
Puyan Lotfi399b46c2018-03-30 18:15:54 +00001036 if (Token.is(MIToken::NamedVirtualRegister))
1037 return parseNamedVirtualRegister(Info);
Matthias Braun74ad41c2016-10-11 03:13:01 +00001038 assert(Token.is(MIToken::VirtualRegister) && "Needs VirtualRegister token");
1039 unsigned ID;
1040 if (getUnsigned(ID))
1041 return true;
1042 Info = &PFS.getVRegInfo(ID);
1043 return false;
1044}
1045
1046bool MIParser::parseRegister(unsigned &Reg, VRegInfo *&Info) {
Alex Lorenzf3db51de2015-06-23 16:35:26 +00001047 switch (Token.kind()) {
Alex Lorenz12b554e2015-06-24 17:34:58 +00001048 case MIToken::underscore:
1049 Reg = 0;
Matthias Braun74ad41c2016-10-11 03:13:01 +00001050 return false;
1051 case MIToken::NamedRegister:
1052 return parseNamedRegister(Reg);
Puyan Lotfi399b46c2018-03-30 18:15:54 +00001053 case MIToken::NamedVirtualRegister:
Matthias Braun74ad41c2016-10-11 03:13:01 +00001054 case MIToken::VirtualRegister:
1055 if (parseVirtualRegister(Info))
Alex Lorenz53464512015-07-10 22:51:20 +00001056 return true;
Matthias Braun74ad41c2016-10-11 03:13:01 +00001057 Reg = Info->VReg;
1058 return false;
Alex Lorenzf3db51de2015-06-23 16:35:26 +00001059 // TODO: Parse other register kinds.
1060 default:
1061 llvm_unreachable("The current token should be a register");
1062 }
Alex Lorenzf3db51de2015-06-23 16:35:26 +00001063}
1064
Matthias Braunde5fea22017-01-18 00:59:19 +00001065bool MIParser::parseRegisterClassOrBank(VRegInfo &RegInfo) {
Ahmed Bougachabf480552017-01-20 00:29:59 +00001066 if (Token.isNot(MIToken::Identifier) && Token.isNot(MIToken::underscore))
1067 return error("expected '_', register class, or register bank name");
Matthias Braunde5fea22017-01-18 00:59:19 +00001068 StringRef::iterator Loc = Token.location();
1069 StringRef Name = Token.stringValue();
1070
1071 // Was it a register class?
1072 auto RCNameI = PFS.Names2RegClasses.find(Name);
1073 if (RCNameI != PFS.Names2RegClasses.end()) {
1074 lex();
1075 const TargetRegisterClass &RC = *RCNameI->getValue();
1076
1077 switch (RegInfo.Kind) {
1078 case VRegInfo::UNKNOWN:
1079 case VRegInfo::NORMAL:
1080 RegInfo.Kind = VRegInfo::NORMAL;
1081 if (RegInfo.Explicit && RegInfo.D.RC != &RC) {
1082 const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
1083 return error(Loc, Twine("conflicting register classes, previously: ") +
1084 Twine(TRI.getRegClassName(RegInfo.D.RC)));
1085 }
1086 RegInfo.D.RC = &RC;
1087 RegInfo.Explicit = true;
1088 return false;
1089
1090 case VRegInfo::GENERIC:
1091 case VRegInfo::REGBANK:
1092 return error(Loc, "register class specification on generic register");
1093 }
1094 llvm_unreachable("Unexpected register kind");
1095 }
1096
Ahmed Bougachabf480552017-01-20 00:29:59 +00001097 // Should be a register bank or a generic register.
1098 const RegisterBank *RegBank = nullptr;
1099 if (Name != "_") {
1100 auto RBNameI = PFS.Names2RegBanks.find(Name);
1101 if (RBNameI == PFS.Names2RegBanks.end())
1102 return error(Loc, "expected '_', register class, or register bank name");
1103 RegBank = RBNameI->getValue();
1104 }
Matthias Braunde5fea22017-01-18 00:59:19 +00001105
Ahmed Bougachabf480552017-01-20 00:29:59 +00001106 lex();
1107
Matthias Braunde5fea22017-01-18 00:59:19 +00001108 switch (RegInfo.Kind) {
1109 case VRegInfo::UNKNOWN:
1110 case VRegInfo::GENERIC:
1111 case VRegInfo::REGBANK:
Ahmed Bougachabf480552017-01-20 00:29:59 +00001112 RegInfo.Kind = RegBank ? VRegInfo::REGBANK : VRegInfo::GENERIC;
1113 if (RegInfo.Explicit && RegInfo.D.RegBank != RegBank)
1114 return error(Loc, "conflicting generic register banks");
1115 RegInfo.D.RegBank = RegBank;
Matthias Braunde5fea22017-01-18 00:59:19 +00001116 RegInfo.Explicit = true;
1117 return false;
1118
1119 case VRegInfo::NORMAL:
Ahmed Bougachabf480552017-01-20 00:29:59 +00001120 return error(Loc, "register bank specification on normal register");
Matthias Braunde5fea22017-01-18 00:59:19 +00001121 }
1122 llvm_unreachable("Unexpected register kind");
1123}
1124
Alex Lorenzcb268d42015-07-06 23:07:26 +00001125bool MIParser::parseRegisterFlag(unsigned &Flags) {
Alex Lorenz2b3cf192015-08-05 18:09:03 +00001126 const unsigned OldFlags = Flags;
Alex Lorenzcb268d42015-07-06 23:07:26 +00001127 switch (Token.kind()) {
1128 case MIToken::kw_implicit:
1129 Flags |= RegState::Implicit;
1130 break;
1131 case MIToken::kw_implicit_define:
1132 Flags |= RegState::ImplicitDefine;
1133 break;
Alex Lorenze66a7cc2015-08-19 18:55:47 +00001134 case MIToken::kw_def:
1135 Flags |= RegState::Define;
1136 break;
Alex Lorenzcbbfd0b2015-07-07 20:34:53 +00001137 case MIToken::kw_dead:
1138 Flags |= RegState::Dead;
1139 break;
Alex Lorenz495ad872015-07-08 21:23:34 +00001140 case MIToken::kw_killed:
1141 Flags |= RegState::Kill;
1142 break;
Alex Lorenz4d026b892015-07-08 23:58:31 +00001143 case MIToken::kw_undef:
1144 Flags |= RegState::Undef;
1145 break;
Alex Lorenz1039fd12015-08-14 19:07:07 +00001146 case MIToken::kw_internal:
1147 Flags |= RegState::InternalRead;
1148 break;
Alex Lorenz01c1a5e2015-08-05 17:49:03 +00001149 case MIToken::kw_early_clobber:
1150 Flags |= RegState::EarlyClobber;
1151 break;
Alex Lorenz90752582015-08-05 17:41:17 +00001152 case MIToken::kw_debug_use:
1153 Flags |= RegState::Debug;
1154 break;
Geoff Berry60c43102017-12-12 17:53:59 +00001155 case MIToken::kw_renamable:
1156 Flags |= RegState::Renamable;
1157 break;
Alex Lorenzcb268d42015-07-06 23:07:26 +00001158 default:
1159 llvm_unreachable("The current token should be a register flag");
1160 }
Alex Lorenz2b3cf192015-08-05 18:09:03 +00001161 if (OldFlags == Flags)
1162 // We know that the same flag is specified more than once when the flags
1163 // weren't modified.
1164 return error("duplicate '" + Token.stringValue() + "' register flag");
Alex Lorenzcb268d42015-07-06 23:07:26 +00001165 lex();
1166 return false;
1167}
1168
Alex Lorenz2eacca82015-07-13 23:24:34 +00001169bool MIParser::parseSubRegisterIndex(unsigned &SubReg) {
Matthias Braun333e4682016-07-26 21:49:34 +00001170 assert(Token.is(MIToken::dot));
Alex Lorenz2eacca82015-07-13 23:24:34 +00001171 lex();
1172 if (Token.isNot(MIToken::Identifier))
Matthias Braun333e4682016-07-26 21:49:34 +00001173 return error("expected a subregister index after '.'");
Alex Lorenz2eacca82015-07-13 23:24:34 +00001174 auto Name = Token.stringValue();
1175 SubReg = getSubRegIndex(Name);
1176 if (!SubReg)
1177 return error(Twine("use of unknown subregister index '") + Name + "'");
1178 lex();
1179 return false;
1180}
1181
Alex Lorenz5ef93b02015-08-19 19:05:34 +00001182bool MIParser::parseRegisterTiedDefIndex(unsigned &TiedDefIdx) {
1183 if (!consumeIfPresent(MIToken::kw_tied_def))
Tim Northoverd28d3cc2016-09-12 11:20:10 +00001184 return true;
Alex Lorenz5ef93b02015-08-19 19:05:34 +00001185 if (Token.isNot(MIToken::IntegerLiteral))
1186 return error("expected an integer literal after 'tied-def'");
1187 if (getUnsigned(TiedDefIdx))
1188 return true;
1189 lex();
1190 if (expectAndConsume(MIToken::rparen))
1191 return true;
1192 return false;
1193}
1194
Alex Lorenzfeb6b432015-08-19 19:19:16 +00001195bool MIParser::assignRegisterTies(MachineInstr &MI,
1196 ArrayRef<ParsedMachineOperand> Operands) {
Alex Lorenz5ef93b02015-08-19 19:05:34 +00001197 SmallVector<std::pair<unsigned, unsigned>, 4> TiedRegisterPairs;
1198 for (unsigned I = 0, E = Operands.size(); I != E; ++I) {
1199 if (!Operands[I].TiedDefIdx)
1200 continue;
1201 // The parser ensures that this operand is a register use, so we just have
1202 // to check the tied-def operand.
1203 unsigned DefIdx = Operands[I].TiedDefIdx.getValue();
1204 if (DefIdx >= E)
1205 return error(Operands[I].Begin,
1206 Twine("use of invalid tied-def operand index '" +
1207 Twine(DefIdx) + "'; instruction has only ") +
1208 Twine(E) + " operands");
1209 const auto &DefOperand = Operands[DefIdx].Operand;
1210 if (!DefOperand.isReg() || !DefOperand.isDef())
1211 // FIXME: add note with the def operand.
1212 return error(Operands[I].Begin,
1213 Twine("use of invalid tied-def operand index '") +
1214 Twine(DefIdx) + "'; the operand #" + Twine(DefIdx) +
1215 " isn't a defined register");
1216 // Check that the tied-def operand wasn't tied elsewhere.
1217 for (const auto &TiedPair : TiedRegisterPairs) {
1218 if (TiedPair.first == DefIdx)
1219 return error(Operands[I].Begin,
1220 Twine("the tied-def operand #") + Twine(DefIdx) +
1221 " is already tied with another register operand");
1222 }
1223 TiedRegisterPairs.push_back(std::make_pair(DefIdx, I));
1224 }
1225 // FIXME: Verify that for non INLINEASM instructions, the def and use tied
1226 // indices must be less than tied max.
1227 for (const auto &TiedPair : TiedRegisterPairs)
1228 MI.tieOperands(TiedPair.first, TiedPair.second);
1229 return false;
1230}
1231
1232bool MIParser::parseRegisterOperand(MachineOperand &Dest,
1233 Optional<unsigned> &TiedDefIdx,
1234 bool IsDef) {
Alex Lorenzcb268d42015-07-06 23:07:26 +00001235 unsigned Flags = IsDef ? RegState::Define : 0;
1236 while (Token.isRegisterFlag()) {
1237 if (parseRegisterFlag(Flags))
1238 return true;
1239 }
1240 if (!Token.isRegister())
1241 return error("expected a register after register flags");
Matthias Braun74ad41c2016-10-11 03:13:01 +00001242 unsigned Reg;
1243 VRegInfo *RegInfo;
1244 if (parseRegister(Reg, RegInfo))
Alex Lorenzf3db51de2015-06-23 16:35:26 +00001245 return true;
1246 lex();
Alex Lorenz2eacca82015-07-13 23:24:34 +00001247 unsigned SubReg = 0;
Matthias Braun333e4682016-07-26 21:49:34 +00001248 if (Token.is(MIToken::dot)) {
Alex Lorenz2eacca82015-07-13 23:24:34 +00001249 if (parseSubRegisterIndex(SubReg))
1250 return true;
Matthias Braun5d00b322016-07-16 01:36:18 +00001251 if (!TargetRegisterInfo::isVirtualRegister(Reg))
1252 return error("subregister index expects a virtual register");
Alex Lorenz2eacca82015-07-13 23:24:34 +00001253 }
Matthias Braunde5fea22017-01-18 00:59:19 +00001254 if (Token.is(MIToken::colon)) {
1255 if (!TargetRegisterInfo::isVirtualRegister(Reg))
1256 return error("register class specification expects a virtual register");
1257 lex();
1258 if (parseRegisterClassOrBank(*RegInfo))
1259 return true;
1260 }
Tim Northoverd28d3cc2016-09-12 11:20:10 +00001261 MachineRegisterInfo &MRI = MF.getRegInfo();
Quentin Colombet2a831fb2016-03-07 21:48:43 +00001262 if ((Flags & RegState::Define) == 0) {
1263 if (consumeIfPresent(MIToken::lparen)) {
1264 unsigned Idx;
Tim Northoverd28d3cc2016-09-12 11:20:10 +00001265 if (!parseRegisterTiedDefIndex(Idx))
1266 TiedDefIdx = Idx;
1267 else {
1268 // Try a redundant low-level type.
1269 LLT Ty;
1270 if (parseLowLevelType(Token.location(), Ty))
1271 return error("expected tied-def or low-level type after '('");
1272
1273 if (expectAndConsume(MIToken::rparen))
1274 return true;
1275
1276 if (MRI.getType(Reg).isValid() && MRI.getType(Reg) != Ty)
1277 return error("inconsistent type for generic virtual register");
1278
1279 MRI.setType(Reg, Ty);
1280 }
Quentin Colombet2a831fb2016-03-07 21:48:43 +00001281 }
1282 } else if (consumeIfPresent(MIToken::lparen)) {
Quentin Colombete08cc592016-12-22 21:56:35 +00001283 // Virtual registers may have a tpe with GlobalISel.
Quentin Colombet2a831fb2016-03-07 21:48:43 +00001284 if (!TargetRegisterInfo::isVirtualRegister(Reg))
Quentin Colombete08cc592016-12-22 21:56:35 +00001285 return error("unexpected type on physical register");
Ahmed Bougacha5a59b242016-07-19 19:48:36 +00001286
Tim Northover0f140c72016-09-09 11:46:34 +00001287 LLT Ty;
1288 if (parseLowLevelType(Token.location(), Ty))
Alex Lorenz5ef93b02015-08-19 19:05:34 +00001289 return true;
Quentin Colombet2a831fb2016-03-07 21:48:43 +00001290
Tim Northover0f140c72016-09-09 11:46:34 +00001291 if (expectAndConsume(MIToken::rparen))
1292 return true;
1293
Tim Northoverd28d3cc2016-09-12 11:20:10 +00001294 if (MRI.getType(Reg).isValid() && MRI.getType(Reg) != Ty)
1295 return error("inconsistent type for generic virtual register");
1296
Tim Northover0f140c72016-09-09 11:46:34 +00001297 MRI.setType(Reg, Ty);
Matthias Braun74ad41c2016-10-11 03:13:01 +00001298 } else if (TargetRegisterInfo::isVirtualRegister(Reg)) {
Quentin Colombet3749f332016-12-22 22:50:34 +00001299 // Generic virtual registers must have a type.
1300 // If we end up here this means the type hasn't been specified and
Quentin Colombet2c646962016-06-08 23:27:46 +00001301 // this is bad!
Matthias Braun74ad41c2016-10-11 03:13:01 +00001302 if (RegInfo->Kind == VRegInfo::GENERIC ||
1303 RegInfo->Kind == VRegInfo::REGBANK)
Quentin Colombet3749f332016-12-22 22:50:34 +00001304 return error("generic virtual registers must have a type");
Alex Lorenz5ef93b02015-08-19 19:05:34 +00001305 }
Alex Lorenz495ad872015-07-08 21:23:34 +00001306 Dest = MachineOperand::CreateReg(
1307 Reg, Flags & RegState::Define, Flags & RegState::Implicit,
Alex Lorenz2eacca82015-07-13 23:24:34 +00001308 Flags & RegState::Kill, Flags & RegState::Dead, Flags & RegState::Undef,
Alex Lorenz1039fd12015-08-14 19:07:07 +00001309 Flags & RegState::EarlyClobber, SubReg, Flags & RegState::Debug,
Geoff Berry60c43102017-12-12 17:53:59 +00001310 Flags & RegState::InternalRead, Flags & RegState::Renamable);
1311
Alex Lorenzf3db51de2015-06-23 16:35:26 +00001312 return false;
1313}
1314
Alex Lorenz240fc1e2015-06-23 23:42:28 +00001315bool MIParser::parseImmediateOperand(MachineOperand &Dest) {
1316 assert(Token.is(MIToken::IntegerLiteral));
1317 const APSInt &Int = Token.integerValue();
1318 if (Int.getMinSignedBits() > 64)
Alex Lorenz3f2058d2015-08-05 19:03:42 +00001319 return error("integer literal is too large to be an immediate operand");
Alex Lorenz240fc1e2015-06-23 23:42:28 +00001320 Dest = MachineOperand::CreateImm(Int.getExtValue());
1321 lex();
1322 return false;
1323}
1324
Alex Lorenz5d8b0bd2015-08-21 21:48:22 +00001325bool MIParser::parseIRConstant(StringRef::iterator Loc, StringRef StringValue,
1326 const Constant *&C) {
1327 auto Source = StringValue.str(); // The source has to be null terminated.
Alex Lorenz7eaff4c2015-08-05 18:44:00 +00001328 SMDiagnostic Err;
Matthias Braunf1caa282017-12-15 22:22:58 +00001329 C = parseConstantValue(Source, Err, *MF.getFunction().getParent(),
Matthias Braune35861d2016-07-13 23:27:50 +00001330 &PFS.IRSlots);
Alex Lorenz7eaff4c2015-08-05 18:44:00 +00001331 if (!C)
1332 return error(Loc + Err.getColumnNo(), Err.getMessage());
1333 return false;
1334}
1335
Alex Lorenz5d8b0bd2015-08-21 21:48:22 +00001336bool MIParser::parseIRConstant(StringRef::iterator Loc, const Constant *&C) {
1337 if (parseIRConstant(Loc, StringRef(Loc, Token.range().end() - Loc), C))
1338 return true;
1339 lex();
1340 return false;
1341}
1342
Matt Arsenault8a59b192019-02-04 22:59:56 +00001343// See LLT implemntation for bit size limits.
1344static bool verifyScalarSize(uint64_t Size) {
1345 return Size != 0 && isUInt<16>(Size);
1346}
1347
1348static bool verifyVectorElementCount(uint64_t NumElts) {
1349 return NumElts != 0 && isUInt<16>(NumElts);
1350}
1351
1352static bool verifyAddrSpace(uint64_t AddrSpace) {
1353 return isUInt<24>(AddrSpace);
1354}
1355
Ahmed Bougachad760de02016-07-28 17:15:12 +00001356bool MIParser::parseLowLevelType(StringRef::iterator Loc, LLT &Ty) {
Heejin Ahnc86da6b2018-05-05 20:53:23 +00001357 if (Token.range().front() == 's' || Token.range().front() == 'p') {
1358 StringRef SizeStr = Token.range().drop_front();
1359 if (SizeStr.size() == 0 || !llvm::all_of(SizeStr, isdigit))
Roman Tereshin5e51fac2018-05-08 02:02:50 +00001360 return error("expected integers after 's'/'p' type character");
Heejin Ahnc86da6b2018-05-05 20:53:23 +00001361 }
Heejin Ahnc2ad0962018-05-05 07:05:51 +00001362
1363 if (Token.range().front() == 's') {
Matt Arsenault8a59b192019-02-04 22:59:56 +00001364 auto ScalarSize = APSInt(Token.range().drop_front()).getZExtValue();
1365 if (!verifyScalarSize(ScalarSize))
1366 return error("invalid size for scalar type");
1367
1368 Ty = LLT::scalar(ScalarSize);
Tim Northover62ae5682016-07-20 19:09:30 +00001369 lex();
1370 return false;
Heejin Ahnc2ad0962018-05-05 07:05:51 +00001371 } else if (Token.range().front() == 'p') {
Matthias Braunf1caa282017-12-15 22:22:58 +00001372 const DataLayout &DL = MF.getDataLayout();
Matt Arsenault8a59b192019-02-04 22:59:56 +00001373 uint64_t AS = APSInt(Token.range().drop_front()).getZExtValue();
1374 if (!verifyAddrSpace(AS))
1375 return error("invalid address space number");
1376
Tim Northover5ae83502016-09-15 09:20:34 +00001377 Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
Tim Northoverbd505462016-07-22 16:59:52 +00001378 lex();
1379 return false;
Tim Northover62ae5682016-07-20 19:09:30 +00001380 }
Quentin Colombet85199672016-03-08 00:20:48 +00001381
Tim Northover62ae5682016-07-20 19:09:30 +00001382 // Now we're looking for a vector.
1383 if (Token.isNot(MIToken::less))
Tim Northoverbd505462016-07-22 16:59:52 +00001384 return error(Loc,
Roman Tereshin5e51fac2018-05-08 02:02:50 +00001385 "expected sN, pA, <M x sN>, or <M x pA> for GlobalISel type");
Tim Northover62ae5682016-07-20 19:09:30 +00001386 lex();
1387
1388 if (Token.isNot(MIToken::IntegerLiteral))
Roman Tereshin5e51fac2018-05-08 02:02:50 +00001389 return error(Loc, "expected <M x sN> or <M x pA> for vector type");
Tim Northover62ae5682016-07-20 19:09:30 +00001390 uint64_t NumElements = Token.integerValue().getZExtValue();
Matt Arsenault8a59b192019-02-04 22:59:56 +00001391 if (!verifyVectorElementCount(NumElements))
1392 return error("invalid number of vector elements");
1393
Tim Northover62ae5682016-07-20 19:09:30 +00001394 lex();
1395
1396 if (Token.isNot(MIToken::Identifier) || Token.stringValue() != "x")
Roman Tereshin5e51fac2018-05-08 02:02:50 +00001397 return error(Loc, "expected <M x sN> or <M x pA> for vector type");
Tim Northover62ae5682016-07-20 19:09:30 +00001398 lex();
1399
Roman Tereshin5e51fac2018-05-08 02:02:50 +00001400 if (Token.range().front() != 's' && Token.range().front() != 'p')
1401 return error(Loc, "expected <M x sN> or <M x pA> for vector type");
Heejin Ahnc86da6b2018-05-05 20:53:23 +00001402 StringRef SizeStr = Token.range().drop_front();
1403 if (SizeStr.size() == 0 || !llvm::all_of(SizeStr, isdigit))
Roman Tereshin5e51fac2018-05-08 02:02:50 +00001404 return error("expected integers after 's'/'p' type character");
1405
Matt Arsenault8a59b192019-02-04 22:59:56 +00001406 if (Token.range().front() == 's') {
1407 auto ScalarSize = APSInt(Token.range().drop_front()).getZExtValue();
1408 if (!verifyScalarSize(ScalarSize))
1409 return error("invalid size for scalar type");
1410 Ty = LLT::scalar(ScalarSize);
1411 } else if (Token.range().front() == 'p') {
Roman Tereshin5e51fac2018-05-08 02:02:50 +00001412 const DataLayout &DL = MF.getDataLayout();
Matt Arsenault8a59b192019-02-04 22:59:56 +00001413 uint64_t AS = APSInt(Token.range().drop_front()).getZExtValue();
1414 if (!verifyAddrSpace(AS))
1415 return error("invalid address space number");
1416
Roman Tereshin5e51fac2018-05-08 02:02:50 +00001417 Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
1418 } else
1419 return error(Loc, "expected <M x sN> or <M x pA> for vector type");
Tim Northover62ae5682016-07-20 19:09:30 +00001420 lex();
1421
1422 if (Token.isNot(MIToken::greater))
Roman Tereshin5e51fac2018-05-08 02:02:50 +00001423 return error(Loc, "expected <M x sN> or <M x pA> for vector type");
Tim Northover62ae5682016-07-20 19:09:30 +00001424 lex();
1425
Roman Tereshin5e51fac2018-05-08 02:02:50 +00001426 Ty = LLT::vector(NumElements, Ty);
Quentin Colombet85199672016-03-08 00:20:48 +00001427 return false;
1428}
1429
Alex Lorenz05e38822015-08-05 18:52:21 +00001430bool MIParser::parseTypedImmediateOperand(MachineOperand &Dest) {
Heejin Ahnc2ad0962018-05-05 07:05:51 +00001431 assert(Token.is(MIToken::Identifier));
Heejin Ahnc86da6b2018-05-05 20:53:23 +00001432 StringRef TypeStr = Token.range();
1433 if (TypeStr.front() != 'i' && TypeStr.front() != 's' &&
1434 TypeStr.front() != 'p')
1435 return error(
Roman Tereshin5e51fac2018-05-08 02:02:50 +00001436 "a typed immediate operand should start with one of 'i', 's', or 'p'");
Heejin Ahnc86da6b2018-05-05 20:53:23 +00001437 StringRef SizeStr = Token.range().drop_front();
1438 if (SizeStr.size() == 0 || !llvm::all_of(SizeStr, isdigit))
Roman Tereshin5e51fac2018-05-08 02:02:50 +00001439 return error("expected integers after 'i'/'s'/'p' type character");
Heejin Ahnc2ad0962018-05-05 07:05:51 +00001440
Alex Lorenz05e38822015-08-05 18:52:21 +00001441 auto Loc = Token.location();
1442 lex();
Amara Emersond496cc82018-06-05 00:17:13 +00001443 if (Token.isNot(MIToken::IntegerLiteral)) {
1444 if (Token.isNot(MIToken::Identifier) ||
1445 !(Token.range() == "true" || Token.range() == "false"))
1446 return error("expected an integer literal");
1447 }
Alex Lorenz05e38822015-08-05 18:52:21 +00001448 const Constant *C = nullptr;
1449 if (parseIRConstant(Loc, C))
1450 return true;
1451 Dest = MachineOperand::CreateCImm(cast<ConstantInt>(C));
1452 return false;
1453}
1454
Alex Lorenzad156fb2015-07-31 20:49:21 +00001455bool MIParser::parseFPImmediateOperand(MachineOperand &Dest) {
1456 auto Loc = Token.location();
1457 lex();
Krzysztof Parzyszekd62669d2016-10-12 21:06:45 +00001458 if (Token.isNot(MIToken::FloatingPointLiteral) &&
1459 Token.isNot(MIToken::HexLiteral))
Alex Lorenzad156fb2015-07-31 20:49:21 +00001460 return error("expected a floating point literal");
Alex Lorenz7eaff4c2015-08-05 18:44:00 +00001461 const Constant *C = nullptr;
1462 if (parseIRConstant(Loc, C))
1463 return true;
Alex Lorenzad156fb2015-07-31 20:49:21 +00001464 Dest = MachineOperand::CreateFPImm(cast<ConstantFP>(C));
1465 return false;
1466}
1467
Alex Lorenz33f0aef2015-06-26 16:46:11 +00001468bool MIParser::getUnsigned(unsigned &Result) {
Krzysztof Parzyszekd62669d2016-10-12 21:06:45 +00001469 if (Token.hasIntegerValue()) {
1470 const uint64_t Limit = uint64_t(std::numeric_limits<unsigned>::max()) + 1;
1471 uint64_t Val64 = Token.integerValue().getLimitedValue(Limit);
1472 if (Val64 == Limit)
1473 return error("expected 32-bit integer (too large)");
1474 Result = Val64;
1475 return false;
1476 }
1477 if (Token.is(MIToken::HexLiteral)) {
Krzysztof Parzyszek36ef5dc2016-12-16 13:58:01 +00001478 APInt A;
1479 if (getHexUint(A))
Krzysztof Parzyszekd62669d2016-10-12 21:06:45 +00001480 return true;
Krzysztof Parzyszek36ef5dc2016-12-16 13:58:01 +00001481 if (A.getBitWidth() > 32)
Krzysztof Parzyszekd62669d2016-10-12 21:06:45 +00001482 return error("expected 32-bit integer (too large)");
1483 Result = A.getZExtValue();
1484 return false;
1485 }
1486 return true;
Alex Lorenz33f0aef2015-06-26 16:46:11 +00001487}
1488
Alex Lorenzf09df002015-06-30 18:16:42 +00001489bool MIParser::parseMBBReference(MachineBasicBlock *&MBB) {
Alex Lorenz5022f6b2015-08-13 23:10:16 +00001490 assert(Token.is(MIToken::MachineBasicBlock) ||
1491 Token.is(MIToken::MachineBasicBlockLabel));
Alex Lorenz33f0aef2015-06-26 16:46:11 +00001492 unsigned Number;
1493 if (getUnsigned(Number))
1494 return true;
Alex Lorenz7a503fa2015-07-07 17:46:43 +00001495 auto MBBInfo = PFS.MBBSlots.find(Number);
1496 if (MBBInfo == PFS.MBBSlots.end())
Alex Lorenz33f0aef2015-06-26 16:46:11 +00001497 return error(Twine("use of undefined machine basic block #") +
1498 Twine(Number));
Alex Lorenzf09df002015-06-30 18:16:42 +00001499 MBB = MBBInfo->second;
Francis Visoiu Mistrih25528d62017-12-04 17:18:51 +00001500 // TODO: Only parse the name if it's a MachineBasicBlockLabel. Deprecate once
1501 // we drop the <irname> from the bb.<id>.<irname> format.
Alex Lorenz33f0aef2015-06-26 16:46:11 +00001502 if (!Token.stringValue().empty() && Token.stringValue() != MBB->getName())
1503 return error(Twine("the name of machine basic block #") + Twine(Number) +
1504 " isn't '" + Token.stringValue() + "'");
Alex Lorenzf09df002015-06-30 18:16:42 +00001505 return false;
1506}
1507
1508bool MIParser::parseMBBOperand(MachineOperand &Dest) {
1509 MachineBasicBlock *MBB;
1510 if (parseMBBReference(MBB))
1511 return true;
Alex Lorenz33f0aef2015-06-26 16:46:11 +00001512 Dest = MachineOperand::CreateMBB(MBB);
1513 lex();
1514 return false;
1515}
1516
Alex Lorenzdc9dadf2015-08-18 22:18:52 +00001517bool MIParser::parseStackFrameIndex(int &FI) {
Alex Lorenz7feaf7c2015-07-16 23:37:45 +00001518 assert(Token.is(MIToken::StackObject));
1519 unsigned ID;
1520 if (getUnsigned(ID))
1521 return true;
1522 auto ObjectInfo = PFS.StackObjectSlots.find(ID);
1523 if (ObjectInfo == PFS.StackObjectSlots.end())
1524 return error(Twine("use of undefined stack object '%stack.") + Twine(ID) +
1525 "'");
1526 StringRef Name;
1527 if (const auto *Alloca =
Matthias Braun941a7052016-07-28 18:40:00 +00001528 MF.getFrameInfo().getObjectAllocation(ObjectInfo->second))
Alex Lorenz7feaf7c2015-07-16 23:37:45 +00001529 Name = Alloca->getName();
1530 if (!Token.stringValue().empty() && Token.stringValue() != Name)
1531 return error(Twine("the name of the stack object '%stack.") + Twine(ID) +
1532 "' isn't '" + Token.stringValue() + "'");
1533 lex();
Alex Lorenzdc9dadf2015-08-18 22:18:52 +00001534 FI = ObjectInfo->second;
1535 return false;
1536}
1537
1538bool MIParser::parseStackObjectOperand(MachineOperand &Dest) {
1539 int FI;
1540 if (parseStackFrameIndex(FI))
1541 return true;
1542 Dest = MachineOperand::CreateFI(FI);
Alex Lorenz7feaf7c2015-07-16 23:37:45 +00001543 return false;
1544}
1545
Alex Lorenzea882122015-08-12 21:17:02 +00001546bool MIParser::parseFixedStackFrameIndex(int &FI) {
Alex Lorenz7feaf7c2015-07-16 23:37:45 +00001547 assert(Token.is(MIToken::FixedStackObject));
1548 unsigned ID;
1549 if (getUnsigned(ID))
1550 return true;
1551 auto ObjectInfo = PFS.FixedStackObjectSlots.find(ID);
1552 if (ObjectInfo == PFS.FixedStackObjectSlots.end())
1553 return error(Twine("use of undefined fixed stack object '%fixed-stack.") +
1554 Twine(ID) + "'");
1555 lex();
Alex Lorenzea882122015-08-12 21:17:02 +00001556 FI = ObjectInfo->second;
1557 return false;
1558}
1559
1560bool MIParser::parseFixedStackObjectOperand(MachineOperand &Dest) {
1561 int FI;
1562 if (parseFixedStackFrameIndex(FI))
1563 return true;
1564 Dest = MachineOperand::CreateFI(FI);
Alex Lorenz7feaf7c2015-07-16 23:37:45 +00001565 return false;
1566}
1567
Alex Lorenz41df7d32015-07-28 17:09:52 +00001568bool MIParser::parseGlobalValue(GlobalValue *&GV) {
Alex Lorenz5d6108e2015-06-26 22:56:48 +00001569 switch (Token.kind()) {
Alex Lorenz970c12e2015-08-05 17:35:55 +00001570 case MIToken::NamedGlobalValue: {
Matthias Braunf1caa282017-12-15 22:22:58 +00001571 const Module *M = MF.getFunction().getParent();
Alex Lorenz970c12e2015-08-05 17:35:55 +00001572 GV = M->getNamedValue(Token.stringValue());
Alex Lorenz41df7d32015-07-28 17:09:52 +00001573 if (!GV)
Alex Lorenz3fb77682015-08-06 23:17:42 +00001574 return error(Twine("use of undefined global value '") + Token.range() +
1575 "'");
Alex Lorenz41df7d32015-07-28 17:09:52 +00001576 break;
Alex Lorenz5d6108e2015-06-26 22:56:48 +00001577 }
1578 case MIToken::GlobalValue: {
1579 unsigned GVIdx;
1580 if (getUnsigned(GVIdx))
1581 return true;
Matthias Braune35861d2016-07-13 23:27:50 +00001582 if (GVIdx >= PFS.IRSlots.GlobalValues.size())
Alex Lorenz5d6108e2015-06-26 22:56:48 +00001583 return error(Twine("use of undefined global value '@") + Twine(GVIdx) +
1584 "'");
Matthias Braune35861d2016-07-13 23:27:50 +00001585 GV = PFS.IRSlots.GlobalValues[GVIdx];
Alex Lorenz5d6108e2015-06-26 22:56:48 +00001586 break;
1587 }
1588 default:
1589 llvm_unreachable("The current token should be a global value");
1590 }
Alex Lorenz41df7d32015-07-28 17:09:52 +00001591 return false;
1592}
1593
1594bool MIParser::parseGlobalAddressOperand(MachineOperand &Dest) {
1595 GlobalValue *GV = nullptr;
1596 if (parseGlobalValue(GV))
1597 return true;
Alex Lorenz5d6108e2015-06-26 22:56:48 +00001598 lex();
Alex Lorenz5672a892015-08-05 22:26:15 +00001599 Dest = MachineOperand::CreateGA(GV, /*Offset=*/0);
Alex Lorenz5672a892015-08-05 22:26:15 +00001600 if (parseOperandsOffset(Dest))
1601 return true;
Alex Lorenz5d6108e2015-06-26 22:56:48 +00001602 return false;
1603}
1604
Alex Lorenzab980492015-07-20 20:51:18 +00001605bool MIParser::parseConstantPoolIndexOperand(MachineOperand &Dest) {
1606 assert(Token.is(MIToken::ConstantPoolItem));
1607 unsigned ID;
1608 if (getUnsigned(ID))
1609 return true;
1610 auto ConstantInfo = PFS.ConstantPoolSlots.find(ID);
1611 if (ConstantInfo == PFS.ConstantPoolSlots.end())
1612 return error("use of undefined constant '%const." + Twine(ID) + "'");
1613 lex();
Alex Lorenzab980492015-07-20 20:51:18 +00001614 Dest = MachineOperand::CreateCPI(ID, /*Offset=*/0);
Alex Lorenz5672a892015-08-05 22:26:15 +00001615 if (parseOperandsOffset(Dest))
1616 return true;
Alex Lorenzab980492015-07-20 20:51:18 +00001617 return false;
1618}
1619
Alex Lorenz31d70682015-07-15 23:38:35 +00001620bool MIParser::parseJumpTableIndexOperand(MachineOperand &Dest) {
1621 assert(Token.is(MIToken::JumpTableIndex));
1622 unsigned ID;
1623 if (getUnsigned(ID))
1624 return true;
1625 auto JumpTableEntryInfo = PFS.JumpTableSlots.find(ID);
1626 if (JumpTableEntryInfo == PFS.JumpTableSlots.end())
1627 return error("use of undefined jump table '%jump-table." + Twine(ID) + "'");
1628 lex();
Alex Lorenz31d70682015-07-15 23:38:35 +00001629 Dest = MachineOperand::CreateJTI(JumpTableEntryInfo->second);
1630 return false;
1631}
1632
Alex Lorenz6ede3742015-07-21 16:59:53 +00001633bool MIParser::parseExternalSymbolOperand(MachineOperand &Dest) {
Alex Lorenz970c12e2015-08-05 17:35:55 +00001634 assert(Token.is(MIToken::ExternalSymbol));
1635 const char *Symbol = MF.createExternalSymbolName(Token.stringValue());
Alex Lorenz6ede3742015-07-21 16:59:53 +00001636 lex();
Alex Lorenz6ede3742015-07-21 16:59:53 +00001637 Dest = MachineOperand::CreateES(Symbol);
Alex Lorenz5672a892015-08-05 22:26:15 +00001638 if (parseOperandsOffset(Dest))
1639 return true;
Alex Lorenz6ede3742015-07-21 16:59:53 +00001640 return false;
1641}
1642
Chandler Carruth75ca6be2018-08-16 23:11:05 +00001643bool MIParser::parseMCSymbolOperand(MachineOperand &Dest) {
1644 assert(Token.is(MIToken::MCSymbol));
1645 MCSymbol *Symbol = getOrCreateMCSymbol(Token.stringValue());
1646 lex();
1647 Dest = MachineOperand::CreateMCSymbol(Symbol);
1648 if (parseOperandsOffset(Dest))
1649 return true;
1650 return false;
1651}
1652
Matthias Braunb74eb412016-03-28 18:18:46 +00001653bool MIParser::parseSubRegisterIndexOperand(MachineOperand &Dest) {
1654 assert(Token.is(MIToken::SubRegisterIndex));
1655 StringRef Name = Token.stringValue();
1656 unsigned SubRegIndex = getSubRegIndex(Token.stringValue());
1657 if (SubRegIndex == 0)
1658 return error(Twine("unknown subregister index '") + Name + "'");
1659 lex();
1660 Dest = MachineOperand::CreateImm(SubRegIndex);
1661 return false;
1662}
1663
Alex Lorenz44f29252015-07-22 21:07:04 +00001664bool MIParser::parseMDNode(MDNode *&Node) {
Alex Lorenz35e44462015-07-22 17:58:46 +00001665 assert(Token.is(MIToken::exclaim));
Reid Kleckner6d353342017-08-23 20:31:27 +00001666
Alex Lorenz35e44462015-07-22 17:58:46 +00001667 auto Loc = Token.location();
1668 lex();
1669 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
1670 return error("expected metadata id after '!'");
1671 unsigned ID;
1672 if (getUnsigned(ID))
1673 return true;
Matthias Braune35861d2016-07-13 23:27:50 +00001674 auto NodeInfo = PFS.IRSlots.MetadataNodes.find(ID);
1675 if (NodeInfo == PFS.IRSlots.MetadataNodes.end())
Alex Lorenz35e44462015-07-22 17:58:46 +00001676 return error(Loc, "use of undefined metadata '!" + Twine(ID) + "'");
1677 lex();
Alex Lorenz44f29252015-07-22 21:07:04 +00001678 Node = NodeInfo->second.get();
1679 return false;
1680}
1681
Reid Kleckner6d353342017-08-23 20:31:27 +00001682bool MIParser::parseDIExpression(MDNode *&Expr) {
1683 assert(Token.is(MIToken::md_diexpr));
1684 lex();
1685
1686 // FIXME: Share this parsing with the IL parser.
1687 SmallVector<uint64_t, 8> Elements;
1688
1689 if (expectAndConsume(MIToken::lparen))
1690 return true;
1691
1692 if (Token.isNot(MIToken::rparen)) {
1693 do {
1694 if (Token.is(MIToken::Identifier)) {
1695 if (unsigned Op = dwarf::getOperationEncoding(Token.stringValue())) {
1696 lex();
1697 Elements.push_back(Op);
1698 continue;
1699 }
1700 return error(Twine("invalid DWARF op '") + Token.stringValue() + "'");
1701 }
1702
1703 if (Token.isNot(MIToken::IntegerLiteral) ||
1704 Token.integerValue().isSigned())
1705 return error("expected unsigned integer");
1706
1707 auto &U = Token.integerValue();
1708 if (U.ugt(UINT64_MAX))
1709 return error("element too large, limit is " + Twine(UINT64_MAX));
1710 Elements.push_back(U.getZExtValue());
1711 lex();
1712
1713 } while (consumeIfPresent(MIToken::comma));
1714 }
1715
1716 if (expectAndConsume(MIToken::rparen))
1717 return true;
1718
Matthias Braunf1caa282017-12-15 22:22:58 +00001719 Expr = DIExpression::get(MF.getFunction().getContext(), Elements);
Reid Kleckner6d353342017-08-23 20:31:27 +00001720 return false;
1721}
1722
Daniel Sanders9f3cf552018-12-13 14:25:27 +00001723bool MIParser::parseDILocation(MDNode *&Loc) {
1724 assert(Token.is(MIToken::md_dilocation));
1725 lex();
1726
1727 bool HaveLine = false;
1728 unsigned Line = 0;
1729 unsigned Column = 0;
1730 MDNode *Scope = nullptr;
1731 MDNode *InlinedAt = nullptr;
Daniel Sandersb51480f2018-12-13 15:05:27 +00001732 bool ImplicitCode = false;
Daniel Sanders9f3cf552018-12-13 14:25:27 +00001733
1734 if (expectAndConsume(MIToken::lparen))
1735 return true;
1736
1737 if (Token.isNot(MIToken::rparen)) {
1738 do {
1739 if (Token.is(MIToken::Identifier)) {
1740 if (Token.stringValue() == "line") {
1741 lex();
1742 if (expectAndConsume(MIToken::colon))
1743 return true;
1744 if (Token.isNot(MIToken::IntegerLiteral) ||
1745 Token.integerValue().isSigned())
1746 return error("expected unsigned integer");
1747 Line = Token.integerValue().getZExtValue();
1748 HaveLine = true;
1749 lex();
1750 continue;
1751 }
1752 if (Token.stringValue() == "column") {
1753 lex();
1754 if (expectAndConsume(MIToken::colon))
1755 return true;
1756 if (Token.isNot(MIToken::IntegerLiteral) ||
1757 Token.integerValue().isSigned())
1758 return error("expected unsigned integer");
1759 Column = Token.integerValue().getZExtValue();
1760 lex();
1761 continue;
1762 }
1763 if (Token.stringValue() == "scope") {
1764 lex();
1765 if (expectAndConsume(MIToken::colon))
1766 return true;
1767 if (parseMDNode(Scope))
1768 return error("expected metadata node");
1769 if (!isa<DIScope>(Scope))
1770 return error("expected DIScope node");
1771 continue;
1772 }
1773 if (Token.stringValue() == "inlinedAt") {
1774 lex();
1775 if (expectAndConsume(MIToken::colon))
1776 return true;
1777 if (Token.is(MIToken::exclaim)) {
1778 if (parseMDNode(InlinedAt))
1779 return true;
1780 } else if (Token.is(MIToken::md_dilocation)) {
1781 if (parseDILocation(InlinedAt))
1782 return true;
1783 } else
1784 return error("expected metadata node");
1785 if (!isa<DILocation>(InlinedAt))
1786 return error("expected DILocation node");
1787 continue;
1788 }
1789 if (Token.stringValue() == "isImplicitCode") {
1790 lex();
1791 if (expectAndConsume(MIToken::colon))
1792 return true;
1793 if (!Token.is(MIToken::Identifier))
1794 return error("expected true/false");
1795 // As far as I can see, we don't have any existing need for parsing
1796 // true/false in MIR yet. Do it ad-hoc until there's something else
1797 // that needs it.
1798 if (Token.stringValue() == "true")
1799 ImplicitCode = true;
1800 else if (Token.stringValue() == "false")
1801 ImplicitCode = false;
1802 else
1803 return error("expected true/false");
1804 lex();
1805 continue;
1806 }
1807 }
1808 return error(Twine("invalid DILocation argument '") +
1809 Token.stringValue() + "'");
1810 } while (consumeIfPresent(MIToken::comma));
1811 }
1812
1813 if (expectAndConsume(MIToken::rparen))
1814 return true;
1815
1816 if (!HaveLine)
1817 return error("DILocation requires line number");
1818 if (!Scope)
1819 return error("DILocation requires a scope");
1820
1821 Loc = DILocation::get(MF.getFunction().getContext(), Line, Column, Scope,
1822 InlinedAt, ImplicitCode);
1823 return false;
1824}
1825
Alex Lorenz44f29252015-07-22 21:07:04 +00001826bool MIParser::parseMetadataOperand(MachineOperand &Dest) {
1827 MDNode *Node = nullptr;
Reid Kleckner6d353342017-08-23 20:31:27 +00001828 if (Token.is(MIToken::exclaim)) {
1829 if (parseMDNode(Node))
1830 return true;
1831 } else if (Token.is(MIToken::md_diexpr)) {
1832 if (parseDIExpression(Node))
1833 return true;
1834 }
Alex Lorenz44f29252015-07-22 21:07:04 +00001835 Dest = MachineOperand::CreateMetadata(Node);
Alex Lorenz35e44462015-07-22 17:58:46 +00001836 return false;
1837}
1838
Alex Lorenzf4baeb52015-07-21 22:28:27 +00001839bool MIParser::parseCFIOffset(int &Offset) {
1840 if (Token.isNot(MIToken::IntegerLiteral))
1841 return error("expected a cfi offset");
1842 if (Token.integerValue().getMinSignedBits() > 32)
1843 return error("expected a 32 bit integer (the cfi offset is too large)");
1844 Offset = (int)Token.integerValue().getExtValue();
1845 lex();
1846 return false;
1847}
1848
Alex Lorenz8cfc6862015-07-23 23:09:07 +00001849bool MIParser::parseCFIRegister(unsigned &Reg) {
1850 if (Token.isNot(MIToken::NamedRegister))
1851 return error("expected a cfi register");
1852 unsigned LLVMReg;
Matthias Braun74ad41c2016-10-11 03:13:01 +00001853 if (parseNamedRegister(LLVMReg))
Alex Lorenzf4baeb52015-07-21 22:28:27 +00001854 return true;
Alex Lorenz8cfc6862015-07-23 23:09:07 +00001855 const auto *TRI = MF.getSubtarget().getRegisterInfo();
1856 assert(TRI && "Expected target register info");
1857 int DwarfReg = TRI->getDwarfRegNum(LLVMReg, true);
1858 if (DwarfReg < 0)
1859 return error("invalid DWARF register");
1860 Reg = (unsigned)DwarfReg;
1861 lex();
1862 return false;
1863}
1864
Francis Visoiu Mistrih5de20e02017-12-15 15:17:18 +00001865bool MIParser::parseCFIEscapeValues(std::string &Values) {
1866 do {
1867 if (Token.isNot(MIToken::HexLiteral))
1868 return error("expected a hexadecimal literal");
1869 unsigned Value;
1870 if (getUnsigned(Value))
1871 return true;
1872 if (Value > UINT8_MAX)
1873 return error("expected a 8-bit integer (too large)");
1874 Values.push_back(static_cast<uint8_t>(Value));
1875 lex();
1876 } while (consumeIfPresent(MIToken::comma));
1877 return false;
1878}
1879
Alex Lorenz8cfc6862015-07-23 23:09:07 +00001880bool MIParser::parseCFIOperand(MachineOperand &Dest) {
1881 auto Kind = Token.kind();
1882 lex();
Alex Lorenz8cfc6862015-07-23 23:09:07 +00001883 int Offset;
1884 unsigned Reg;
1885 unsigned CFIIndex;
1886 switch (Kind) {
Alex Lorenz577d2712015-08-14 21:55:58 +00001887 case MIToken::kw_cfi_same_value:
1888 if (parseCFIRegister(Reg))
1889 return true;
Matthias Braunf23ef432016-11-30 23:48:42 +00001890 CFIIndex = MF.addFrameInst(MCCFIInstruction::createSameValue(nullptr, Reg));
Alex Lorenz577d2712015-08-14 21:55:58 +00001891 break;
Alex Lorenz8cfc6862015-07-23 23:09:07 +00001892 case MIToken::kw_cfi_offset:
1893 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1894 parseCFIOffset(Offset))
1895 return true;
1896 CFIIndex =
Matthias Braunf23ef432016-11-30 23:48:42 +00001897 MF.addFrameInst(MCCFIInstruction::createOffset(nullptr, Reg, Offset));
Alex Lorenz8cfc6862015-07-23 23:09:07 +00001898 break;
Francis Visoiu Mistrih5de20e02017-12-15 15:17:18 +00001899 case MIToken::kw_cfi_rel_offset:
1900 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1901 parseCFIOffset(Offset))
1902 return true;
1903 CFIIndex = MF.addFrameInst(
1904 MCCFIInstruction::createRelOffset(nullptr, Reg, Offset));
1905 break;
Alex Lorenz5b0d5f62015-07-27 20:39:03 +00001906 case MIToken::kw_cfi_def_cfa_register:
1907 if (parseCFIRegister(Reg))
1908 return true;
1909 CFIIndex =
Matthias Braunf23ef432016-11-30 23:48:42 +00001910 MF.addFrameInst(MCCFIInstruction::createDefCfaRegister(nullptr, Reg));
Alex Lorenz5b0d5f62015-07-27 20:39:03 +00001911 break;
Alex Lorenz8cfc6862015-07-23 23:09:07 +00001912 case MIToken::kw_cfi_def_cfa_offset:
1913 if (parseCFIOffset(Offset))
1914 return true;
1915 // NB: MCCFIInstruction::createDefCfaOffset negates the offset.
Matthias Braunf23ef432016-11-30 23:48:42 +00001916 CFIIndex = MF.addFrameInst(
Alex Lorenz8cfc6862015-07-23 23:09:07 +00001917 MCCFIInstruction::createDefCfaOffset(nullptr, -Offset));
1918 break;
Francis Visoiu Mistrih5de20e02017-12-15 15:17:18 +00001919 case MIToken::kw_cfi_adjust_cfa_offset:
1920 if (parseCFIOffset(Offset))
1921 return true;
1922 CFIIndex = MF.addFrameInst(
1923 MCCFIInstruction::createAdjustCfaOffset(nullptr, Offset));
1924 break;
Alex Lorenzb1393232015-07-29 18:57:23 +00001925 case MIToken::kw_cfi_def_cfa:
1926 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1927 parseCFIOffset(Offset))
1928 return true;
1929 // NB: MCCFIInstruction::createDefCfa negates the offset.
1930 CFIIndex =
Matthias Braunf23ef432016-11-30 23:48:42 +00001931 MF.addFrameInst(MCCFIInstruction::createDefCfa(nullptr, Reg, -Offset));
Alex Lorenzb1393232015-07-29 18:57:23 +00001932 break;
Francis Visoiu Mistrih5de20e02017-12-15 15:17:18 +00001933 case MIToken::kw_cfi_remember_state:
1934 CFIIndex = MF.addFrameInst(MCCFIInstruction::createRememberState(nullptr));
1935 break;
Francis Visoiu Mistrih66d2c262017-11-02 12:00:58 +00001936 case MIToken::kw_cfi_restore:
1937 if (parseCFIRegister(Reg))
1938 return true;
1939 CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestore(nullptr, Reg));
1940 break;
Francis Visoiu Mistrih5de20e02017-12-15 15:17:18 +00001941 case MIToken::kw_cfi_restore_state:
1942 CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestoreState(nullptr));
1943 break;
1944 case MIToken::kw_cfi_undefined:
1945 if (parseCFIRegister(Reg))
1946 return true;
1947 CFIIndex = MF.addFrameInst(MCCFIInstruction::createUndefined(nullptr, Reg));
1948 break;
1949 case MIToken::kw_cfi_register: {
1950 unsigned Reg2;
1951 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1952 parseCFIRegister(Reg2))
1953 return true;
Francis Visoiu Mistrih66d2c262017-11-02 12:00:58 +00001954
Francis Visoiu Mistrih5de20e02017-12-15 15:17:18 +00001955 CFIIndex =
1956 MF.addFrameInst(MCCFIInstruction::createRegister(nullptr, Reg, Reg2));
1957 break;
1958 }
1959 case MIToken::kw_cfi_window_save:
1960 CFIIndex = MF.addFrameInst(MCCFIInstruction::createWindowSave(nullptr));
1961 break;
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00001962 case MIToken::kw_cfi_aarch64_negate_ra_sign_state:
1963 CFIIndex = MF.addFrameInst(MCCFIInstruction::createNegateRAState(nullptr));
1964 break;
Francis Visoiu Mistrih5de20e02017-12-15 15:17:18 +00001965 case MIToken::kw_cfi_escape: {
1966 std::string Values;
1967 if (parseCFIEscapeValues(Values))
1968 return true;
1969 CFIIndex = MF.addFrameInst(MCCFIInstruction::createEscape(nullptr, Values));
1970 break;
1971 }
Alex Lorenz8cfc6862015-07-23 23:09:07 +00001972 default:
1973 // TODO: Parse the other CFI operands.
1974 llvm_unreachable("The current token should be a cfi operand");
1975 }
1976 Dest = MachineOperand::CreateCFIIndex(CFIIndex);
Alex Lorenzf4baeb52015-07-21 22:28:27 +00001977 return false;
1978}
1979
Alex Lorenzdeb53492015-07-28 17:28:03 +00001980bool MIParser::parseIRBlock(BasicBlock *&BB, const Function &F) {
1981 switch (Token.kind()) {
Alex Lorenz970c12e2015-08-05 17:35:55 +00001982 case MIToken::NamedIRBlock: {
1983 BB = dyn_cast_or_null<BasicBlock>(
Mehdi Aminia53d49e2016-09-17 06:00:02 +00001984 F.getValueSymbolTable()->lookup(Token.stringValue()));
Alex Lorenzdeb53492015-07-28 17:28:03 +00001985 if (!BB)
Alex Lorenz3fb77682015-08-06 23:17:42 +00001986 return error(Twine("use of undefined IR block '") + Token.range() + "'");
Alex Lorenzdeb53492015-07-28 17:28:03 +00001987 break;
1988 }
1989 case MIToken::IRBlock: {
1990 unsigned SlotNumber = 0;
1991 if (getUnsigned(SlotNumber))
1992 return true;
Alex Lorenzcba8c5f2015-08-06 23:57:04 +00001993 BB = const_cast<BasicBlock *>(getIRBlock(SlotNumber, F));
Alex Lorenzdeb53492015-07-28 17:28:03 +00001994 if (!BB)
1995 return error(Twine("use of undefined IR block '%ir-block.") +
1996 Twine(SlotNumber) + "'");
1997 break;
1998 }
1999 default:
2000 llvm_unreachable("The current token should be an IR block reference");
2001 }
2002 return false;
2003}
2004
2005bool MIParser::parseBlockAddressOperand(MachineOperand &Dest) {
2006 assert(Token.is(MIToken::kw_blockaddress));
2007 lex();
2008 if (expectAndConsume(MIToken::lparen))
2009 return true;
2010 if (Token.isNot(MIToken::GlobalValue) &&
Alex Lorenz970c12e2015-08-05 17:35:55 +00002011 Token.isNot(MIToken::NamedGlobalValue))
Alex Lorenzdeb53492015-07-28 17:28:03 +00002012 return error("expected a global value");
2013 GlobalValue *GV = nullptr;
2014 if (parseGlobalValue(GV))
2015 return true;
2016 auto *F = dyn_cast<Function>(GV);
2017 if (!F)
2018 return error("expected an IR function reference");
2019 lex();
2020 if (expectAndConsume(MIToken::comma))
2021 return true;
2022 BasicBlock *BB = nullptr;
Alex Lorenz970c12e2015-08-05 17:35:55 +00002023 if (Token.isNot(MIToken::IRBlock) && Token.isNot(MIToken::NamedIRBlock))
Alex Lorenzdeb53492015-07-28 17:28:03 +00002024 return error("expected an IR block reference");
2025 if (parseIRBlock(BB, *F))
2026 return true;
2027 lex();
2028 if (expectAndConsume(MIToken::rparen))
2029 return true;
Alex Lorenzdeb53492015-07-28 17:28:03 +00002030 Dest = MachineOperand::CreateBA(BlockAddress::get(F, BB), /*Offset=*/0);
Alex Lorenz5672a892015-08-05 22:26:15 +00002031 if (parseOperandsOffset(Dest))
2032 return true;
Alex Lorenzdeb53492015-07-28 17:28:03 +00002033 return false;
2034}
2035
Tim Northover6b3bd612016-07-29 20:32:59 +00002036bool MIParser::parseIntrinsicOperand(MachineOperand &Dest) {
2037 assert(Token.is(MIToken::kw_intrinsic));
2038 lex();
2039 if (expectAndConsume(MIToken::lparen))
2040 return error("expected syntax intrinsic(@llvm.whatever)");
2041
2042 if (Token.isNot(MIToken::NamedGlobalValue))
2043 return error("expected syntax intrinsic(@llvm.whatever)");
2044
2045 std::string Name = Token.stringValue();
2046 lex();
2047
2048 if (expectAndConsume(MIToken::rparen))
2049 return error("expected ')' to terminate intrinsic name");
2050
2051 // Find out what intrinsic we're dealing with, first try the global namespace
2052 // and then the target's private intrinsics if that fails.
2053 const TargetIntrinsicInfo *TII = MF.getTarget().getIntrinsicInfo();
2054 Intrinsic::ID ID = Function::lookupIntrinsicID(Name);
2055 if (ID == Intrinsic::not_intrinsic && TII)
2056 ID = static_cast<Intrinsic::ID>(TII->lookupName(Name));
2057
2058 if (ID == Intrinsic::not_intrinsic)
2059 return error("unknown intrinsic name");
2060 Dest = MachineOperand::CreateIntrinsicID(ID);
2061
2062 return false;
2063}
2064
Tim Northoverde3aea0412016-08-17 20:25:25 +00002065bool MIParser::parsePredicateOperand(MachineOperand &Dest) {
2066 assert(Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred));
2067 bool IsFloat = Token.is(MIToken::kw_floatpred);
2068 lex();
2069
2070 if (expectAndConsume(MIToken::lparen))
2071 return error("expected syntax intpred(whatever) or floatpred(whatever");
2072
2073 if (Token.isNot(MIToken::Identifier))
2074 return error("whatever");
2075
2076 CmpInst::Predicate Pred;
2077 if (IsFloat) {
2078 Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
2079 .Case("false", CmpInst::FCMP_FALSE)
2080 .Case("oeq", CmpInst::FCMP_OEQ)
2081 .Case("ogt", CmpInst::FCMP_OGT)
2082 .Case("oge", CmpInst::FCMP_OGE)
2083 .Case("olt", CmpInst::FCMP_OLT)
2084 .Case("ole", CmpInst::FCMP_OLE)
2085 .Case("one", CmpInst::FCMP_ONE)
2086 .Case("ord", CmpInst::FCMP_ORD)
2087 .Case("uno", CmpInst::FCMP_UNO)
2088 .Case("ueq", CmpInst::FCMP_UEQ)
2089 .Case("ugt", CmpInst::FCMP_UGT)
2090 .Case("uge", CmpInst::FCMP_UGE)
2091 .Case("ult", CmpInst::FCMP_ULT)
2092 .Case("ule", CmpInst::FCMP_ULE)
2093 .Case("une", CmpInst::FCMP_UNE)
2094 .Case("true", CmpInst::FCMP_TRUE)
2095 .Default(CmpInst::BAD_FCMP_PREDICATE);
2096 if (!CmpInst::isFPPredicate(Pred))
2097 return error("invalid floating-point predicate");
2098 } else {
2099 Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
2100 .Case("eq", CmpInst::ICMP_EQ)
2101 .Case("ne", CmpInst::ICMP_NE)
2102 .Case("sgt", CmpInst::ICMP_SGT)
2103 .Case("sge", CmpInst::ICMP_SGE)
2104 .Case("slt", CmpInst::ICMP_SLT)
2105 .Case("sle", CmpInst::ICMP_SLE)
2106 .Case("ugt", CmpInst::ICMP_UGT)
2107 .Case("uge", CmpInst::ICMP_UGE)
2108 .Case("ult", CmpInst::ICMP_ULT)
2109 .Case("ule", CmpInst::ICMP_ULE)
2110 .Default(CmpInst::BAD_ICMP_PREDICATE);
2111 if (!CmpInst::isIntPredicate(Pred))
2112 return error("invalid integer predicate");
2113 }
2114
2115 lex();
2116 Dest = MachineOperand::CreatePredicate(Pred);
Tim Northover6cd4b232016-08-23 21:01:26 +00002117 if (expectAndConsume(MIToken::rparen))
Tim Northoverde3aea0412016-08-17 20:25:25 +00002118 return error("predicate should be terminated by ')'.");
2119
2120 return false;
2121}
2122
Alex Lorenzef5c1962015-07-28 23:02:45 +00002123bool MIParser::parseTargetIndexOperand(MachineOperand &Dest) {
2124 assert(Token.is(MIToken::kw_target_index));
2125 lex();
2126 if (expectAndConsume(MIToken::lparen))
2127 return true;
2128 if (Token.isNot(MIToken::Identifier))
2129 return error("expected the name of the target index");
2130 int Index = 0;
2131 if (getTargetIndex(Token.stringValue(), Index))
2132 return error("use of undefined target index '" + Token.stringValue() + "'");
2133 lex();
2134 if (expectAndConsume(MIToken::rparen))
2135 return true;
Alex Lorenzef5c1962015-07-28 23:02:45 +00002136 Dest = MachineOperand::CreateTargetIndex(unsigned(Index), /*Offset=*/0);
Alex Lorenz5672a892015-08-05 22:26:15 +00002137 if (parseOperandsOffset(Dest))
2138 return true;
Alex Lorenzef5c1962015-07-28 23:02:45 +00002139 return false;
2140}
2141
Oren Ben Simhon0ef61ec2017-03-19 08:14:18 +00002142bool MIParser::parseCustomRegisterMaskOperand(MachineOperand &Dest) {
2143 assert(Token.stringValue() == "CustomRegMask" && "Expected a custom RegMask");
Oren Ben Simhon0ef61ec2017-03-19 08:14:18 +00002144 lex();
2145 if (expectAndConsume(MIToken::lparen))
2146 return true;
2147
Matthias Braun57dd5b32018-07-26 00:27:47 +00002148 uint32_t *Mask = MF.allocateRegMask();
Oren Ben Simhon0ef61ec2017-03-19 08:14:18 +00002149 while (true) {
2150 if (Token.isNot(MIToken::NamedRegister))
2151 return error("expected a named register");
2152 unsigned Reg;
2153 if (parseNamedRegister(Reg))
2154 return true;
2155 lex();
2156 Mask[Reg / 32] |= 1U << (Reg % 32);
2157 // TODO: Report an error if the same register is used more than once.
2158 if (Token.isNot(MIToken::comma))
2159 break;
2160 lex();
2161 }
2162
2163 if (expectAndConsume(MIToken::rparen))
2164 return true;
2165 Dest = MachineOperand::CreateRegMask(Mask);
2166 return false;
2167}
2168
Alex Lorenzb97c9ef2015-08-10 23:24:42 +00002169bool MIParser::parseLiveoutRegisterMaskOperand(MachineOperand &Dest) {
2170 assert(Token.is(MIToken::kw_liveout));
Matthias Braun57dd5b32018-07-26 00:27:47 +00002171 uint32_t *Mask = MF.allocateRegMask();
Alex Lorenzb97c9ef2015-08-10 23:24:42 +00002172 lex();
2173 if (expectAndConsume(MIToken::lparen))
2174 return true;
2175 while (true) {
2176 if (Token.isNot(MIToken::NamedRegister))
2177 return error("expected a named register");
Matthias Braun74ad41c2016-10-11 03:13:01 +00002178 unsigned Reg;
2179 if (parseNamedRegister(Reg))
Alex Lorenzb97c9ef2015-08-10 23:24:42 +00002180 return true;
2181 lex();
2182 Mask[Reg / 32] |= 1U << (Reg % 32);
2183 // TODO: Report an error if the same register is used more than once.
2184 if (Token.isNot(MIToken::comma))
2185 break;
2186 lex();
2187 }
2188 if (expectAndConsume(MIToken::rparen))
2189 return true;
2190 Dest = MachineOperand::CreateRegLiveOut(Mask);
2191 return false;
2192}
2193
Alex Lorenz5ef93b02015-08-19 19:05:34 +00002194bool MIParser::parseMachineOperand(MachineOperand &Dest,
2195 Optional<unsigned> &TiedDefIdx) {
Alex Lorenzf3db51de2015-06-23 16:35:26 +00002196 switch (Token.kind()) {
Alex Lorenzcb268d42015-07-06 23:07:26 +00002197 case MIToken::kw_implicit:
2198 case MIToken::kw_implicit_define:
Alex Lorenze66a7cc2015-08-19 18:55:47 +00002199 case MIToken::kw_def:
Alex Lorenzcbbfd0b2015-07-07 20:34:53 +00002200 case MIToken::kw_dead:
Alex Lorenz495ad872015-07-08 21:23:34 +00002201 case MIToken::kw_killed:
Alex Lorenz4d026b892015-07-08 23:58:31 +00002202 case MIToken::kw_undef:
Alex Lorenz1039fd12015-08-14 19:07:07 +00002203 case MIToken::kw_internal:
Alex Lorenz01c1a5e2015-08-05 17:49:03 +00002204 case MIToken::kw_early_clobber:
Alex Lorenz90752582015-08-05 17:41:17 +00002205 case MIToken::kw_debug_use:
Geoff Berry60c43102017-12-12 17:53:59 +00002206 case MIToken::kw_renamable:
Alex Lorenz12b554e2015-06-24 17:34:58 +00002207 case MIToken::underscore:
Alex Lorenzf3db51de2015-06-23 16:35:26 +00002208 case MIToken::NamedRegister:
Alex Lorenz53464512015-07-10 22:51:20 +00002209 case MIToken::VirtualRegister:
Puyan Lotfi399b46c2018-03-30 18:15:54 +00002210 case MIToken::NamedVirtualRegister:
Alex Lorenz5ef93b02015-08-19 19:05:34 +00002211 return parseRegisterOperand(Dest, TiedDefIdx);
Alex Lorenz240fc1e2015-06-23 23:42:28 +00002212 case MIToken::IntegerLiteral:
2213 return parseImmediateOperand(Dest);
Alex Lorenzad156fb2015-07-31 20:49:21 +00002214 case MIToken::kw_half:
2215 case MIToken::kw_float:
2216 case MIToken::kw_double:
2217 case MIToken::kw_x86_fp80:
2218 case MIToken::kw_fp128:
2219 case MIToken::kw_ppc_fp128:
2220 return parseFPImmediateOperand(Dest);
Alex Lorenz33f0aef2015-06-26 16:46:11 +00002221 case MIToken::MachineBasicBlock:
2222 return parseMBBOperand(Dest);
Alex Lorenz7feaf7c2015-07-16 23:37:45 +00002223 case MIToken::StackObject:
2224 return parseStackObjectOperand(Dest);
2225 case MIToken::FixedStackObject:
2226 return parseFixedStackObjectOperand(Dest);
Alex Lorenz5d6108e2015-06-26 22:56:48 +00002227 case MIToken::GlobalValue:
2228 case MIToken::NamedGlobalValue:
2229 return parseGlobalAddressOperand(Dest);
Alex Lorenzab980492015-07-20 20:51:18 +00002230 case MIToken::ConstantPoolItem:
2231 return parseConstantPoolIndexOperand(Dest);
Alex Lorenz31d70682015-07-15 23:38:35 +00002232 case MIToken::JumpTableIndex:
2233 return parseJumpTableIndexOperand(Dest);
Alex Lorenz6ede3742015-07-21 16:59:53 +00002234 case MIToken::ExternalSymbol:
Alex Lorenz6ede3742015-07-21 16:59:53 +00002235 return parseExternalSymbolOperand(Dest);
Chandler Carruth75ca6be2018-08-16 23:11:05 +00002236 case MIToken::MCSymbol:
2237 return parseMCSymbolOperand(Dest);
Matthias Braunb74eb412016-03-28 18:18:46 +00002238 case MIToken::SubRegisterIndex:
2239 return parseSubRegisterIndexOperand(Dest);
Reid Kleckner6d353342017-08-23 20:31:27 +00002240 case MIToken::md_diexpr:
Alex Lorenz35e44462015-07-22 17:58:46 +00002241 case MIToken::exclaim:
2242 return parseMetadataOperand(Dest);
Alex Lorenz577d2712015-08-14 21:55:58 +00002243 case MIToken::kw_cfi_same_value:
Alex Lorenz8cfc6862015-07-23 23:09:07 +00002244 case MIToken::kw_cfi_offset:
Francis Visoiu Mistrih5de20e02017-12-15 15:17:18 +00002245 case MIToken::kw_cfi_rel_offset:
Alex Lorenz5b0d5f62015-07-27 20:39:03 +00002246 case MIToken::kw_cfi_def_cfa_register:
Alex Lorenzf4baeb52015-07-21 22:28:27 +00002247 case MIToken::kw_cfi_def_cfa_offset:
Francis Visoiu Mistrih5de20e02017-12-15 15:17:18 +00002248 case MIToken::kw_cfi_adjust_cfa_offset:
2249 case MIToken::kw_cfi_escape:
Alex Lorenzb1393232015-07-29 18:57:23 +00002250 case MIToken::kw_cfi_def_cfa:
Francis Visoiu Mistrih5de20e02017-12-15 15:17:18 +00002251 case MIToken::kw_cfi_register:
2252 case MIToken::kw_cfi_remember_state:
Francis Visoiu Mistrih66d2c262017-11-02 12:00:58 +00002253 case MIToken::kw_cfi_restore:
Francis Visoiu Mistrih5de20e02017-12-15 15:17:18 +00002254 case MIToken::kw_cfi_restore_state:
2255 case MIToken::kw_cfi_undefined:
2256 case MIToken::kw_cfi_window_save:
Luke Cheesemanf57d7d82018-12-18 10:37:42 +00002257 case MIToken::kw_cfi_aarch64_negate_ra_sign_state:
Alex Lorenzf4baeb52015-07-21 22:28:27 +00002258 return parseCFIOperand(Dest);
Alex Lorenzdeb53492015-07-28 17:28:03 +00002259 case MIToken::kw_blockaddress:
2260 return parseBlockAddressOperand(Dest);
Tim Northover6b3bd612016-07-29 20:32:59 +00002261 case MIToken::kw_intrinsic:
2262 return parseIntrinsicOperand(Dest);
Alex Lorenzef5c1962015-07-28 23:02:45 +00002263 case MIToken::kw_target_index:
2264 return parseTargetIndexOperand(Dest);
Alex Lorenzb97c9ef2015-08-10 23:24:42 +00002265 case MIToken::kw_liveout:
2266 return parseLiveoutRegisterMaskOperand(Dest);
Tim Northoverde3aea0412016-08-17 20:25:25 +00002267 case MIToken::kw_floatpred:
2268 case MIToken::kw_intpred:
2269 return parsePredicateOperand(Dest);
Alex Lorenzf3db51de2015-06-23 16:35:26 +00002270 case MIToken::Error:
2271 return true;
Alex Lorenz8f6f4282015-06-29 16:57:06 +00002272 case MIToken::Identifier:
2273 if (const auto *RegMask = getRegMask(Token.stringValue())) {
2274 Dest = MachineOperand::CreateRegMask(RegMask);
2275 lex();
2276 break;
Heejin Ahnc2ad0962018-05-05 07:05:51 +00002277 } else if (Token.stringValue() == "CustomRegMask") {
Oren Ben Simhon0ef61ec2017-03-19 08:14:18 +00002278 return parseCustomRegisterMaskOperand(Dest);
Heejin Ahnc2ad0962018-05-05 07:05:51 +00002279 } else
2280 return parseTypedImmediateOperand(Dest);
Alex Lorenzf3db51de2015-06-23 16:35:26 +00002281 default:
Alex Lorenzf22ca8a2015-08-21 21:12:44 +00002282 // FIXME: Parse the MCSymbol machine operand.
Alex Lorenzf3db51de2015-06-23 16:35:26 +00002283 return error("expected a machine operand");
2284 }
Alex Lorenz91370c52015-06-22 20:37:46 +00002285 return false;
2286}
2287
Alex Lorenz5ef93b02015-08-19 19:05:34 +00002288bool MIParser::parseMachineOperandAndTargetFlags(
2289 MachineOperand &Dest, Optional<unsigned> &TiedDefIdx) {
Alex Lorenz49873a82015-08-06 00:44:07 +00002290 unsigned TF = 0;
2291 bool HasTargetFlags = false;
2292 if (Token.is(MIToken::kw_target_flags)) {
2293 HasTargetFlags = true;
2294 lex();
2295 if (expectAndConsume(MIToken::lparen))
2296 return true;
2297 if (Token.isNot(MIToken::Identifier))
2298 return error("expected the name of the target flag");
Alex Lorenzf3630112015-08-18 22:52:15 +00002299 if (getDirectTargetFlag(Token.stringValue(), TF)) {
2300 if (getBitmaskTargetFlag(Token.stringValue(), TF))
2301 return error("use of undefined target flag '" + Token.stringValue() +
2302 "'");
2303 }
Alex Lorenz49873a82015-08-06 00:44:07 +00002304 lex();
Alex Lorenzf3630112015-08-18 22:52:15 +00002305 while (Token.is(MIToken::comma)) {
2306 lex();
2307 if (Token.isNot(MIToken::Identifier))
2308 return error("expected the name of the target flag");
2309 unsigned BitFlag = 0;
2310 if (getBitmaskTargetFlag(Token.stringValue(), BitFlag))
2311 return error("use of undefined target flag '" + Token.stringValue() +
2312 "'");
2313 // TODO: Report an error when using a duplicate bit target flag.
2314 TF |= BitFlag;
2315 lex();
2316 }
Alex Lorenz49873a82015-08-06 00:44:07 +00002317 if (expectAndConsume(MIToken::rparen))
2318 return true;
2319 }
2320 auto Loc = Token.location();
Alex Lorenz5ef93b02015-08-19 19:05:34 +00002321 if (parseMachineOperand(Dest, TiedDefIdx))
Alex Lorenz49873a82015-08-06 00:44:07 +00002322 return true;
2323 if (!HasTargetFlags)
2324 return false;
2325 if (Dest.isReg())
2326 return error(Loc, "register operands can't have target flags");
2327 Dest.setTargetFlags(TF);
2328 return false;
2329}
2330
Alex Lorenzdc24c172015-08-07 20:21:00 +00002331bool MIParser::parseOffset(int64_t &Offset) {
Alex Lorenz5672a892015-08-05 22:26:15 +00002332 if (Token.isNot(MIToken::plus) && Token.isNot(MIToken::minus))
2333 return false;
Alex Lorenz3fb77682015-08-06 23:17:42 +00002334 StringRef Sign = Token.range();
Alex Lorenz5672a892015-08-05 22:26:15 +00002335 bool IsNegative = Token.is(MIToken::minus);
2336 lex();
2337 if (Token.isNot(MIToken::IntegerLiteral))
2338 return error("expected an integer literal after '" + Sign + "'");
2339 if (Token.integerValue().getMinSignedBits() > 64)
2340 return error("expected 64-bit integer (too large)");
Alex Lorenzdc24c172015-08-07 20:21:00 +00002341 Offset = Token.integerValue().getExtValue();
Alex Lorenz5672a892015-08-05 22:26:15 +00002342 if (IsNegative)
2343 Offset = -Offset;
2344 lex();
Alex Lorenzdc24c172015-08-07 20:21:00 +00002345 return false;
2346}
2347
Alex Lorenz620f8912015-08-13 20:33:33 +00002348bool MIParser::parseAlignment(unsigned &Alignment) {
2349 assert(Token.is(MIToken::kw_align));
2350 lex();
Alex Lorenz68661042015-08-13 20:55:01 +00002351 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
Alex Lorenz620f8912015-08-13 20:33:33 +00002352 return error("expected an integer literal after 'align'");
2353 if (getUnsigned(Alignment))
2354 return true;
2355 lex();
Matt Arsenault547a83b2019-01-30 23:09:28 +00002356
2357 if (!isPowerOf2_32(Alignment))
2358 return error("expected a power-of-2 literal after 'align'");
2359
Alex Lorenz620f8912015-08-13 20:33:33 +00002360 return false;
2361}
2362
Francis Visoiu Mistrihe4718e82018-01-26 11:47:28 +00002363bool MIParser::parseAddrspace(unsigned &Addrspace) {
2364 assert(Token.is(MIToken::kw_addrspace));
2365 lex();
2366 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
2367 return error("expected an integer literal after 'addrspace'");
2368 if (getUnsigned(Addrspace))
2369 return true;
2370 lex();
2371 return false;
2372}
2373
Alex Lorenzdc24c172015-08-07 20:21:00 +00002374bool MIParser::parseOperandsOffset(MachineOperand &Op) {
2375 int64_t Offset = 0;
2376 if (parseOffset(Offset))
2377 return true;
Alex Lorenz5672a892015-08-05 22:26:15 +00002378 Op.setOffset(Offset);
2379 return false;
2380}
2381
Alex Lorenz36593ac2015-08-19 23:27:07 +00002382bool MIParser::parseIRValue(const Value *&V) {
Alex Lorenz4af7e612015-08-03 23:08:19 +00002383 switch (Token.kind()) {
Alex Lorenz970c12e2015-08-05 17:35:55 +00002384 case MIToken::NamedIRValue: {
Matthias Braunf1caa282017-12-15 22:22:58 +00002385 V = MF.getFunction().getValueSymbolTable()->lookup(Token.stringValue());
Alex Lorenz4af7e612015-08-03 23:08:19 +00002386 break;
2387 }
Alex Lorenzdd13be02015-08-19 23:31:05 +00002388 case MIToken::IRValue: {
2389 unsigned SlotNumber = 0;
2390 if (getUnsigned(SlotNumber))
2391 return true;
2392 V = getIRValue(SlotNumber);
2393 break;
2394 }
Alex Lorenz36efd382015-08-20 00:20:03 +00002395 case MIToken::NamedGlobalValue:
2396 case MIToken::GlobalValue: {
2397 GlobalValue *GV = nullptr;
2398 if (parseGlobalValue(GV))
2399 return true;
2400 V = GV;
2401 break;
2402 }
Alex Lorenzc1136ef32015-08-21 21:54:12 +00002403 case MIToken::QuotedIRValue: {
2404 const Constant *C = nullptr;
2405 if (parseIRConstant(Token.location(), Token.stringValue(), C))
2406 return true;
2407 V = C;
2408 break;
2409 }
Alex Lorenz4af7e612015-08-03 23:08:19 +00002410 default:
2411 llvm_unreachable("The current token should be an IR block reference");
2412 }
Alex Lorenzdd13be02015-08-19 23:31:05 +00002413 if (!V)
2414 return error(Twine("use of undefined IR value '") + Token.range() + "'");
Alex Lorenz4af7e612015-08-03 23:08:19 +00002415 return false;
2416}
2417
2418bool MIParser::getUint64(uint64_t &Result) {
Krzysztof Parzyszek36ef5dc2016-12-16 13:58:01 +00002419 if (Token.hasIntegerValue()) {
2420 if (Token.integerValue().getActiveBits() > 64)
2421 return error("expected 64-bit integer (too large)");
2422 Result = Token.integerValue().getZExtValue();
2423 return false;
2424 }
2425 if (Token.is(MIToken::HexLiteral)) {
2426 APInt A;
2427 if (getHexUint(A))
2428 return true;
2429 if (A.getBitWidth() > 64)
2430 return error("expected 64-bit integer (too large)");
2431 Result = A.getZExtValue();
2432 return false;
2433 }
2434 return true;
2435}
2436
2437bool MIParser::getHexUint(APInt &Result) {
2438 assert(Token.is(MIToken::HexLiteral));
2439 StringRef S = Token.range();
2440 assert(S[0] == '0' && tolower(S[1]) == 'x');
2441 // This could be a floating point literal with a special prefix.
2442 if (!isxdigit(S[2]))
2443 return true;
2444 StringRef V = S.substr(2);
2445 APInt A(V.size()*4, V, 16);
Jessica Paquetteb0d17d92017-09-01 22:17:14 +00002446
2447 // If A is 0, then A.getActiveBits() is 0. This isn't a valid bitwidth. Make
2448 // sure it isn't the case before constructing result.
2449 unsigned NumBits = (A == 0) ? 32 : A.getActiveBits();
2450 Result = APInt(NumBits, ArrayRef<uint64_t>(A.getRawData(), A.getNumWords()));
Alex Lorenz4af7e612015-08-03 23:08:19 +00002451 return false;
2452}
2453
Justin Lebar0af80cd2016-07-15 18:26:59 +00002454bool MIParser::parseMemoryOperandFlag(MachineMemOperand::Flags &Flags) {
2455 const auto OldFlags = Flags;
Alex Lorenza518b792015-08-04 00:24:45 +00002456 switch (Token.kind()) {
2457 case MIToken::kw_volatile:
2458 Flags |= MachineMemOperand::MOVolatile;
2459 break;
Alex Lorenz10fd0382015-08-06 16:49:30 +00002460 case MIToken::kw_non_temporal:
2461 Flags |= MachineMemOperand::MONonTemporal;
2462 break;
Justin Lebaradbf09e2016-09-11 01:38:58 +00002463 case MIToken::kw_dereferenceable:
2464 Flags |= MachineMemOperand::MODereferenceable;
2465 break;
Alex Lorenzdc8de2a2015-08-06 16:55:53 +00002466 case MIToken::kw_invariant:
2467 Flags |= MachineMemOperand::MOInvariant;
2468 break;
Geoff Berry6748abe2017-07-13 02:28:54 +00002469 case MIToken::StringConstant: {
2470 MachineMemOperand::Flags TF;
2471 if (getMMOTargetFlag(Token.stringValue(), TF))
2472 return error("use of undefined target MMO flag '" + Token.stringValue() +
2473 "'");
2474 Flags |= TF;
2475 break;
2476 }
Alex Lorenza518b792015-08-04 00:24:45 +00002477 default:
2478 llvm_unreachable("The current token should be a memory operand flag");
2479 }
Alex Lorenze86d5152015-08-06 18:26:36 +00002480 if (OldFlags == Flags)
2481 // We know that the same flag is specified more than once when the flags
2482 // weren't modified.
2483 return error("duplicate '" + Token.stringValue() + "' memory operand flag");
Alex Lorenza518b792015-08-04 00:24:45 +00002484 lex();
2485 return false;
2486}
2487
Alex Lorenz91097a32015-08-12 20:33:26 +00002488bool MIParser::parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV) {
2489 switch (Token.kind()) {
Alex Lorenz46e95582015-08-12 20:44:16 +00002490 case MIToken::kw_stack:
2491 PSV = MF.getPSVManager().getStack();
2492 break;
Alex Lorenzd858f872015-08-12 21:00:22 +00002493 case MIToken::kw_got:
2494 PSV = MF.getPSVManager().getGOT();
2495 break;
Alex Lorenz4be56e92015-08-12 21:11:08 +00002496 case MIToken::kw_jump_table:
2497 PSV = MF.getPSVManager().getJumpTable();
2498 break;
Alex Lorenz91097a32015-08-12 20:33:26 +00002499 case MIToken::kw_constant_pool:
2500 PSV = MF.getPSVManager().getConstantPool();
2501 break;
Alex Lorenz0cc671b2015-08-12 21:23:17 +00002502 case MIToken::FixedStackObject: {
2503 int FI;
2504 if (parseFixedStackFrameIndex(FI))
2505 return true;
2506 PSV = MF.getPSVManager().getFixedStack(FI);
2507 // The token was already consumed, so use return here instead of break.
2508 return false;
2509 }
Matthias Braun3ef7df92016-06-08 00:47:07 +00002510 case MIToken::StackObject: {
2511 int FI;
2512 if (parseStackFrameIndex(FI))
2513 return true;
2514 PSV = MF.getPSVManager().getFixedStack(FI);
2515 // The token was already consumed, so use return here instead of break.
2516 return false;
2517 }
Eugene Zelenkofb69e662017-06-06 22:22:41 +00002518 case MIToken::kw_call_entry:
Alex Lorenz0d009642015-08-20 00:12:57 +00002519 lex();
2520 switch (Token.kind()) {
2521 case MIToken::GlobalValue:
2522 case MIToken::NamedGlobalValue: {
2523 GlobalValue *GV = nullptr;
2524 if (parseGlobalValue(GV))
2525 return true;
2526 PSV = MF.getPSVManager().getGlobalValueCallEntry(GV);
2527 break;
2528 }
2529 case MIToken::ExternalSymbol:
2530 PSV = MF.getPSVManager().getExternalSymbolCallEntry(
2531 MF.createExternalSymbolName(Token.stringValue()));
2532 break;
2533 default:
2534 return error(
2535 "expected a global value or an external symbol after 'call-entry'");
2536 }
Alex Lorenz50b826f2015-08-14 21:08:30 +00002537 break;
Alex Lorenz91097a32015-08-12 20:33:26 +00002538 default:
2539 llvm_unreachable("The current token should be pseudo source value");
2540 }
2541 lex();
2542 return false;
2543}
2544
2545bool MIParser::parseMachinePointerInfo(MachinePointerInfo &Dest) {
Alex Lorenzd858f872015-08-12 21:00:22 +00002546 if (Token.is(MIToken::kw_constant_pool) || Token.is(MIToken::kw_stack) ||
Alex Lorenz0cc671b2015-08-12 21:23:17 +00002547 Token.is(MIToken::kw_got) || Token.is(MIToken::kw_jump_table) ||
Matthias Braun3ef7df92016-06-08 00:47:07 +00002548 Token.is(MIToken::FixedStackObject) || Token.is(MIToken::StackObject) ||
2549 Token.is(MIToken::kw_call_entry)) {
Alex Lorenz91097a32015-08-12 20:33:26 +00002550 const PseudoSourceValue *PSV = nullptr;
2551 if (parseMemoryPseudoSourceValue(PSV))
2552 return true;
2553 int64_t Offset = 0;
2554 if (parseOffset(Offset))
2555 return true;
2556 Dest = MachinePointerInfo(PSV, Offset);
2557 return false;
2558 }
Alex Lorenz36efd382015-08-20 00:20:03 +00002559 if (Token.isNot(MIToken::NamedIRValue) && Token.isNot(MIToken::IRValue) &&
2560 Token.isNot(MIToken::GlobalValue) &&
Alex Lorenzc1136ef32015-08-21 21:54:12 +00002561 Token.isNot(MIToken::NamedGlobalValue) &&
2562 Token.isNot(MIToken::QuotedIRValue))
Alex Lorenz91097a32015-08-12 20:33:26 +00002563 return error("expected an IR value reference");
Alex Lorenz36593ac2015-08-19 23:27:07 +00002564 const Value *V = nullptr;
Alex Lorenz91097a32015-08-12 20:33:26 +00002565 if (parseIRValue(V))
2566 return true;
2567 if (!V->getType()->isPointerTy())
2568 return error("expected a pointer IR value");
2569 lex();
2570 int64_t Offset = 0;
2571 if (parseOffset(Offset))
2572 return true;
2573 Dest = MachinePointerInfo(V, Offset);
2574 return false;
2575}
2576
Konstantin Zhuravlyovbb80d3e2017-07-11 22:23:00 +00002577bool MIParser::parseOptionalScope(LLVMContext &Context,
2578 SyncScope::ID &SSID) {
2579 SSID = SyncScope::System;
2580 if (Token.is(MIToken::Identifier) && Token.stringValue() == "syncscope") {
2581 lex();
2582 if (expectAndConsume(MIToken::lparen))
2583 return error("expected '(' in syncscope");
2584
2585 std::string SSN;
2586 if (parseStringConstant(SSN))
2587 return true;
2588
2589 SSID = Context.getOrInsertSyncScopeID(SSN);
2590 if (expectAndConsume(MIToken::rparen))
2591 return error("expected ')' in syncscope");
2592 }
2593
2594 return false;
2595}
2596
Tim Northoverb73e3092017-02-13 22:14:08 +00002597bool MIParser::parseOptionalAtomicOrdering(AtomicOrdering &Order) {
2598 Order = AtomicOrdering::NotAtomic;
2599 if (Token.isNot(MIToken::Identifier))
2600 return false;
2601
2602 Order = StringSwitch<AtomicOrdering>(Token.stringValue())
2603 .Case("unordered", AtomicOrdering::Unordered)
2604 .Case("monotonic", AtomicOrdering::Monotonic)
2605 .Case("acquire", AtomicOrdering::Acquire)
2606 .Case("release", AtomicOrdering::Release)
2607 .Case("acq_rel", AtomicOrdering::AcquireRelease)
2608 .Case("seq_cst", AtomicOrdering::SequentiallyConsistent)
2609 .Default(AtomicOrdering::NotAtomic);
2610
2611 if (Order != AtomicOrdering::NotAtomic) {
2612 lex();
2613 return false;
2614 }
2615
Krzysztof Parzyszekcc3f6302018-08-20 20:37:57 +00002616 return error("expected an atomic scope, ordering or a size specification");
Tim Northoverb73e3092017-02-13 22:14:08 +00002617}
2618
Alex Lorenz4af7e612015-08-03 23:08:19 +00002619bool MIParser::parseMachineMemoryOperand(MachineMemOperand *&Dest) {
2620 if (expectAndConsume(MIToken::lparen))
2621 return true;
Justin Lebar0af80cd2016-07-15 18:26:59 +00002622 MachineMemOperand::Flags Flags = MachineMemOperand::MONone;
Alex Lorenza518b792015-08-04 00:24:45 +00002623 while (Token.isMemoryOperandFlag()) {
2624 if (parseMemoryOperandFlag(Flags))
2625 return true;
2626 }
Alex Lorenz4af7e612015-08-03 23:08:19 +00002627 if (Token.isNot(MIToken::Identifier) ||
2628 (Token.stringValue() != "load" && Token.stringValue() != "store"))
2629 return error("expected 'load' or 'store' memory operation");
Alex Lorenz4af7e612015-08-03 23:08:19 +00002630 if (Token.stringValue() == "load")
2631 Flags |= MachineMemOperand::MOLoad;
2632 else
2633 Flags |= MachineMemOperand::MOStore;
2634 lex();
2635
Daniel Sanders17d277b2017-11-28 18:57:02 +00002636 // Optional 'store' for operands that both load and store.
2637 if (Token.is(MIToken::Identifier) && Token.stringValue() == "store") {
2638 Flags |= MachineMemOperand::MOStore;
2639 lex();
2640 }
2641
Konstantin Zhuravlyovbb80d3e2017-07-11 22:23:00 +00002642 // Optional synchronization scope.
2643 SyncScope::ID SSID;
Matthias Braunf1caa282017-12-15 22:22:58 +00002644 if (parseOptionalScope(MF.getFunction().getContext(), SSID))
Konstantin Zhuravlyovbb80d3e2017-07-11 22:23:00 +00002645 return true;
Tim Northoverb73e3092017-02-13 22:14:08 +00002646
2647 // Up to two atomic orderings (cmpxchg provides guarantees on failure).
2648 AtomicOrdering Order, FailureOrder;
2649 if (parseOptionalAtomicOrdering(Order))
2650 return true;
2651
2652 if (parseOptionalAtomicOrdering(FailureOrder))
2653 return true;
2654
Krzysztof Parzyszekcc3f6302018-08-20 20:37:57 +00002655 if (Token.isNot(MIToken::IntegerLiteral) &&
2656 Token.isNot(MIToken::kw_unknown_size))
2657 return error("expected the size integer literal or 'unknown-size' after "
2658 "memory operation");
Alex Lorenz4af7e612015-08-03 23:08:19 +00002659 uint64_t Size;
Krzysztof Parzyszekcc3f6302018-08-20 20:37:57 +00002660 if (Token.is(MIToken::IntegerLiteral)) {
2661 if (getUint64(Size))
2662 return true;
2663 } else if (Token.is(MIToken::kw_unknown_size)) {
2664 Size = MemoryLocation::UnknownSize;
2665 }
Alex Lorenz4af7e612015-08-03 23:08:19 +00002666 lex();
2667
Alex Lorenz91097a32015-08-12 20:33:26 +00002668 MachinePointerInfo Ptr = MachinePointerInfo();
Matthias Braunc25c9cc2016-06-04 00:06:31 +00002669 if (Token.is(MIToken::Identifier)) {
Daniel Sanders17d277b2017-11-28 18:57:02 +00002670 const char *Word =
2671 ((Flags & MachineMemOperand::MOLoad) &&
2672 (Flags & MachineMemOperand::MOStore))
2673 ? "on"
2674 : Flags & MachineMemOperand::MOLoad ? "from" : "into";
Matthias Braunc25c9cc2016-06-04 00:06:31 +00002675 if (Token.stringValue() != Word)
2676 return error(Twine("expected '") + Word + "'");
2677 lex();
2678
2679 if (parseMachinePointerInfo(Ptr))
2680 return true;
2681 }
Krzysztof Parzyszekcc3f6302018-08-20 20:37:57 +00002682 unsigned BaseAlignment = (Size != MemoryLocation::UnknownSize ? Size : 1);
Alex Lorenza617c912015-08-17 22:05:15 +00002683 AAMDNodes AAInfo;
Alex Lorenzeb625682015-08-17 22:09:52 +00002684 MDNode *Range = nullptr;
Alex Lorenza617c912015-08-17 22:05:15 +00002685 while (consumeIfPresent(MIToken::comma)) {
2686 switch (Token.kind()) {
2687 case MIToken::kw_align:
2688 if (parseAlignment(BaseAlignment))
2689 return true;
2690 break;
Francis Visoiu Mistrihe4718e82018-01-26 11:47:28 +00002691 case MIToken::kw_addrspace:
2692 if (parseAddrspace(Ptr.AddrSpace))
2693 return true;
2694 break;
Alex Lorenza617c912015-08-17 22:05:15 +00002695 case MIToken::md_tbaa:
2696 lex();
2697 if (parseMDNode(AAInfo.TBAA))
2698 return true;
2699 break;
Alex Lorenza16f6242015-08-17 22:06:40 +00002700 case MIToken::md_alias_scope:
2701 lex();
2702 if (parseMDNode(AAInfo.Scope))
2703 return true;
2704 break;
Alex Lorenz03e940d2015-08-17 22:08:02 +00002705 case MIToken::md_noalias:
2706 lex();
2707 if (parseMDNode(AAInfo.NoAlias))
2708 return true;
2709 break;
Alex Lorenzeb625682015-08-17 22:09:52 +00002710 case MIToken::md_range:
2711 lex();
2712 if (parseMDNode(Range))
2713 return true;
2714 break;
Alex Lorenza617c912015-08-17 22:05:15 +00002715 // TODO: Report an error on duplicate metadata nodes.
2716 default:
Alex Lorenzeb625682015-08-17 22:09:52 +00002717 return error("expected 'align' or '!tbaa' or '!alias.scope' or "
2718 "'!noalias' or '!range'");
Alex Lorenza617c912015-08-17 22:05:15 +00002719 }
Alex Lorenz61420f72015-08-07 20:48:30 +00002720 }
Alex Lorenz4af7e612015-08-03 23:08:19 +00002721 if (expectAndConsume(MIToken::rparen))
2722 return true;
Tim Northoverb73e3092017-02-13 22:14:08 +00002723 Dest = MF.getMachineMemOperand(Ptr, Flags, Size, BaseAlignment, AAInfo, Range,
Konstantin Zhuravlyovbb80d3e2017-07-11 22:23:00 +00002724 SSID, Order, FailureOrder);
Alex Lorenz4af7e612015-08-03 23:08:19 +00002725 return false;
2726}
2727
Chandler Carruth75ca6be2018-08-16 23:11:05 +00002728bool MIParser::parsePreOrPostInstrSymbol(MCSymbol *&Symbol) {
2729 assert((Token.is(MIToken::kw_pre_instr_symbol) ||
2730 Token.is(MIToken::kw_post_instr_symbol)) &&
2731 "Invalid token for a pre- post-instruction symbol!");
2732 lex();
2733 if (Token.isNot(MIToken::MCSymbol))
2734 return error("expected a symbol after 'pre-instr-symbol'");
2735 Symbol = getOrCreateMCSymbol(Token.stringValue());
2736 lex();
2737 if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
2738 Token.is(MIToken::lbrace))
2739 return false;
2740 if (Token.isNot(MIToken::comma))
2741 return error("expected ',' before the next machine operand");
2742 lex();
2743 return false;
2744}
2745
Alex Lorenz8e0a1b42015-06-22 17:02:30 +00002746void MIParser::initNames2InstrOpCodes() {
2747 if (!Names2InstrOpCodes.empty())
2748 return;
2749 const auto *TII = MF.getSubtarget().getInstrInfo();
2750 assert(TII && "Expected target instruction info");
2751 for (unsigned I = 0, E = TII->getNumOpcodes(); I < E; ++I)
2752 Names2InstrOpCodes.insert(std::make_pair(StringRef(TII->getName(I)), I));
2753}
2754
2755bool MIParser::parseInstrName(StringRef InstrName, unsigned &OpCode) {
2756 initNames2InstrOpCodes();
2757 auto InstrInfo = Names2InstrOpCodes.find(InstrName);
2758 if (InstrInfo == Names2InstrOpCodes.end())
2759 return true;
2760 OpCode = InstrInfo->getValue();
2761 return false;
2762}
2763
Alex Lorenzf3db51de2015-06-23 16:35:26 +00002764void MIParser::initNames2Regs() {
2765 if (!Names2Regs.empty())
2766 return;
Alex Lorenz12b554e2015-06-24 17:34:58 +00002767 // The '%noreg' register is the register 0.
2768 Names2Regs.insert(std::make_pair("noreg", 0));
Alex Lorenzf3db51de2015-06-23 16:35:26 +00002769 const auto *TRI = MF.getSubtarget().getRegisterInfo();
2770 assert(TRI && "Expected target register info");
2771 for (unsigned I = 0, E = TRI->getNumRegs(); I < E; ++I) {
2772 bool WasInserted =
2773 Names2Regs.insert(std::make_pair(StringRef(TRI->getName(I)).lower(), I))
2774 .second;
2775 (void)WasInserted;
2776 assert(WasInserted && "Expected registers to be unique case-insensitively");
2777 }
2778}
2779
2780bool MIParser::getRegisterByName(StringRef RegName, unsigned &Reg) {
2781 initNames2Regs();
2782 auto RegInfo = Names2Regs.find(RegName);
2783 if (RegInfo == Names2Regs.end())
2784 return true;
2785 Reg = RegInfo->getValue();
2786 return false;
2787}
2788
Alex Lorenz8f6f4282015-06-29 16:57:06 +00002789void MIParser::initNames2RegMasks() {
2790 if (!Names2RegMasks.empty())
2791 return;
2792 const auto *TRI = MF.getSubtarget().getRegisterInfo();
2793 assert(TRI && "Expected target register info");
2794 ArrayRef<const uint32_t *> RegMasks = TRI->getRegMasks();
2795 ArrayRef<const char *> RegMaskNames = TRI->getRegMaskNames();
2796 assert(RegMasks.size() == RegMaskNames.size());
2797 for (size_t I = 0, E = RegMasks.size(); I < E; ++I)
2798 Names2RegMasks.insert(
2799 std::make_pair(StringRef(RegMaskNames[I]).lower(), RegMasks[I]));
2800}
2801
2802const uint32_t *MIParser::getRegMask(StringRef Identifier) {
2803 initNames2RegMasks();
2804 auto RegMaskInfo = Names2RegMasks.find(Identifier);
2805 if (RegMaskInfo == Names2RegMasks.end())
2806 return nullptr;
2807 return RegMaskInfo->getValue();
2808}
2809
Alex Lorenz2eacca82015-07-13 23:24:34 +00002810void MIParser::initNames2SubRegIndices() {
2811 if (!Names2SubRegIndices.empty())
2812 return;
2813 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
2814 for (unsigned I = 1, E = TRI->getNumSubRegIndices(); I < E; ++I)
2815 Names2SubRegIndices.insert(
2816 std::make_pair(StringRef(TRI->getSubRegIndexName(I)).lower(), I));
2817}
2818
2819unsigned MIParser::getSubRegIndex(StringRef Name) {
2820 initNames2SubRegIndices();
2821 auto SubRegInfo = Names2SubRegIndices.find(Name);
2822 if (SubRegInfo == Names2SubRegIndices.end())
2823 return 0;
2824 return SubRegInfo->getValue();
2825}
2826
Alex Lorenzcba8c5f2015-08-06 23:57:04 +00002827static void initSlots2BasicBlocks(
2828 const Function &F,
2829 DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
2830 ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
Alex Lorenz8a1915b2015-07-27 22:42:41 +00002831 MST.incorporateFunction(F);
2832 for (auto &BB : F) {
2833 if (BB.hasName())
2834 continue;
2835 int Slot = MST.getLocalSlot(&BB);
2836 if (Slot == -1)
2837 continue;
2838 Slots2BasicBlocks.insert(std::make_pair(unsigned(Slot), &BB));
2839 }
2840}
2841
Alex Lorenzcba8c5f2015-08-06 23:57:04 +00002842static const BasicBlock *getIRBlockFromSlot(
2843 unsigned Slot,
2844 const DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
Alex Lorenz8a1915b2015-07-27 22:42:41 +00002845 auto BlockInfo = Slots2BasicBlocks.find(Slot);
2846 if (BlockInfo == Slots2BasicBlocks.end())
2847 return nullptr;
2848 return BlockInfo->second;
2849}
2850
Alex Lorenzcba8c5f2015-08-06 23:57:04 +00002851const BasicBlock *MIParser::getIRBlock(unsigned Slot) {
2852 if (Slots2BasicBlocks.empty())
Matthias Braunf1caa282017-12-15 22:22:58 +00002853 initSlots2BasicBlocks(MF.getFunction(), Slots2BasicBlocks);
Alex Lorenzcba8c5f2015-08-06 23:57:04 +00002854 return getIRBlockFromSlot(Slot, Slots2BasicBlocks);
2855}
2856
2857const BasicBlock *MIParser::getIRBlock(unsigned Slot, const Function &F) {
Matthias Braunf1caa282017-12-15 22:22:58 +00002858 if (&F == &MF.getFunction())
Alex Lorenzcba8c5f2015-08-06 23:57:04 +00002859 return getIRBlock(Slot);
2860 DenseMap<unsigned, const BasicBlock *> CustomSlots2BasicBlocks;
2861 initSlots2BasicBlocks(F, CustomSlots2BasicBlocks);
2862 return getIRBlockFromSlot(Slot, CustomSlots2BasicBlocks);
2863}
2864
Alex Lorenzdd13be02015-08-19 23:31:05 +00002865static void mapValueToSlot(const Value *V, ModuleSlotTracker &MST,
2866 DenseMap<unsigned, const Value *> &Slots2Values) {
2867 int Slot = MST.getLocalSlot(V);
2868 if (Slot == -1)
2869 return;
2870 Slots2Values.insert(std::make_pair(unsigned(Slot), V));
2871}
2872
2873/// Creates the mapping from slot numbers to function's unnamed IR values.
2874static void initSlots2Values(const Function &F,
2875 DenseMap<unsigned, const Value *> &Slots2Values) {
2876 ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
2877 MST.incorporateFunction(F);
2878 for (const auto &Arg : F.args())
2879 mapValueToSlot(&Arg, MST, Slots2Values);
2880 for (const auto &BB : F) {
2881 mapValueToSlot(&BB, MST, Slots2Values);
2882 for (const auto &I : BB)
2883 mapValueToSlot(&I, MST, Slots2Values);
2884 }
2885}
2886
2887const Value *MIParser::getIRValue(unsigned Slot) {
2888 if (Slots2Values.empty())
Matthias Braunf1caa282017-12-15 22:22:58 +00002889 initSlots2Values(MF.getFunction(), Slots2Values);
Alex Lorenzdd13be02015-08-19 23:31:05 +00002890 auto ValueInfo = Slots2Values.find(Slot);
2891 if (ValueInfo == Slots2Values.end())
2892 return nullptr;
2893 return ValueInfo->second;
2894}
2895
Alex Lorenzef5c1962015-07-28 23:02:45 +00002896void MIParser::initNames2TargetIndices() {
2897 if (!Names2TargetIndices.empty())
2898 return;
2899 const auto *TII = MF.getSubtarget().getInstrInfo();
2900 assert(TII && "Expected target instruction info");
2901 auto Indices = TII->getSerializableTargetIndices();
2902 for (const auto &I : Indices)
2903 Names2TargetIndices.insert(std::make_pair(StringRef(I.second), I.first));
2904}
2905
2906bool MIParser::getTargetIndex(StringRef Name, int &Index) {
2907 initNames2TargetIndices();
2908 auto IndexInfo = Names2TargetIndices.find(Name);
2909 if (IndexInfo == Names2TargetIndices.end())
2910 return true;
2911 Index = IndexInfo->second;
2912 return false;
2913}
2914
Alex Lorenz49873a82015-08-06 00:44:07 +00002915void MIParser::initNames2DirectTargetFlags() {
2916 if (!Names2DirectTargetFlags.empty())
2917 return;
2918 const auto *TII = MF.getSubtarget().getInstrInfo();
2919 assert(TII && "Expected target instruction info");
2920 auto Flags = TII->getSerializableDirectMachineOperandTargetFlags();
2921 for (const auto &I : Flags)
2922 Names2DirectTargetFlags.insert(
2923 std::make_pair(StringRef(I.second), I.first));
2924}
2925
2926bool MIParser::getDirectTargetFlag(StringRef Name, unsigned &Flag) {
2927 initNames2DirectTargetFlags();
2928 auto FlagInfo = Names2DirectTargetFlags.find(Name);
2929 if (FlagInfo == Names2DirectTargetFlags.end())
2930 return true;
2931 Flag = FlagInfo->second;
2932 return false;
2933}
2934
Alex Lorenzf3630112015-08-18 22:52:15 +00002935void MIParser::initNames2BitmaskTargetFlags() {
2936 if (!Names2BitmaskTargetFlags.empty())
2937 return;
2938 const auto *TII = MF.getSubtarget().getInstrInfo();
2939 assert(TII && "Expected target instruction info");
2940 auto Flags = TII->getSerializableBitmaskMachineOperandTargetFlags();
2941 for (const auto &I : Flags)
2942 Names2BitmaskTargetFlags.insert(
2943 std::make_pair(StringRef(I.second), I.first));
2944}
2945
2946bool MIParser::getBitmaskTargetFlag(StringRef Name, unsigned &Flag) {
2947 initNames2BitmaskTargetFlags();
2948 auto FlagInfo = Names2BitmaskTargetFlags.find(Name);
2949 if (FlagInfo == Names2BitmaskTargetFlags.end())
2950 return true;
2951 Flag = FlagInfo->second;
2952 return false;
2953}
2954
Geoff Berry6748abe2017-07-13 02:28:54 +00002955void MIParser::initNames2MMOTargetFlags() {
2956 if (!Names2MMOTargetFlags.empty())
2957 return;
2958 const auto *TII = MF.getSubtarget().getInstrInfo();
2959 assert(TII && "Expected target instruction info");
2960 auto Flags = TII->getSerializableMachineMemOperandTargetFlags();
2961 for (const auto &I : Flags)
2962 Names2MMOTargetFlags.insert(
2963 std::make_pair(StringRef(I.second), I.first));
2964}
2965
2966bool MIParser::getMMOTargetFlag(StringRef Name,
2967 MachineMemOperand::Flags &Flag) {
2968 initNames2MMOTargetFlags();
2969 auto FlagInfo = Names2MMOTargetFlags.find(Name);
2970 if (FlagInfo == Names2MMOTargetFlags.end())
2971 return true;
2972 Flag = FlagInfo->second;
2973 return false;
2974}
2975
Chandler Carruth75ca6be2018-08-16 23:11:05 +00002976MCSymbol *MIParser::getOrCreateMCSymbol(StringRef Name) {
2977 // FIXME: Currently we can't recognize temporary or local symbols and call all
2978 // of the appropriate forms to create them. However, this handles basic cases
2979 // well as most of the special aspects are recognized by a prefix on their
2980 // name, and the input names should already be unique. For test cases, keeping
2981 // the symbol name out of the symbol table isn't terribly important.
2982 return MF.getContext().getOrCreateSymbol(Name);
2983}
2984
Konstantin Zhuravlyovbb80d3e2017-07-11 22:23:00 +00002985bool MIParser::parseStringConstant(std::string &Result) {
2986 if (Token.isNot(MIToken::StringConstant))
2987 return error("expected string constant");
2988 Result = Token.stringValue();
2989 lex();
2990 return false;
2991}
2992
Matthias Braun83947862016-07-13 22:23:23 +00002993bool llvm::parseMachineBasicBlockDefinitions(PerFunctionMIParsingState &PFS,
2994 StringRef Src,
Alex Lorenz5022f6b2015-08-13 23:10:16 +00002995 SMDiagnostic &Error) {
Matthias Braune35861d2016-07-13 23:27:50 +00002996 return MIParser(PFS, Error, Src).parseBasicBlockDefinitions(PFS.MBBSlots);
Alex Lorenz5022f6b2015-08-13 23:10:16 +00002997}
2998
Matthias Braun74ad41c2016-10-11 03:13:01 +00002999bool llvm::parseMachineInstructions(PerFunctionMIParsingState &PFS,
Matthias Braune35861d2016-07-13 23:27:50 +00003000 StringRef Src, SMDiagnostic &Error) {
3001 return MIParser(PFS, Error, Src).parseBasicBlocks();
Alex Lorenz8e0a1b42015-06-22 17:02:30 +00003002}
Alex Lorenzf09df002015-06-30 18:16:42 +00003003
Matthias Braun74ad41c2016-10-11 03:13:01 +00003004bool llvm::parseMBBReference(PerFunctionMIParsingState &PFS,
Matthias Braune35861d2016-07-13 23:27:50 +00003005 MachineBasicBlock *&MBB, StringRef Src,
Matthias Braun83947862016-07-13 22:23:23 +00003006 SMDiagnostic &Error) {
Matthias Braune35861d2016-07-13 23:27:50 +00003007 return MIParser(PFS, Error, Src).parseStandaloneMBB(MBB);
Alex Lorenzf09df002015-06-30 18:16:42 +00003008}
Alex Lorenz9fab3702015-07-14 21:24:41 +00003009
Tom Stellard9c884e42016-11-15 00:03:14 +00003010bool llvm::parseRegisterReference(PerFunctionMIParsingState &PFS,
3011 unsigned &Reg, StringRef Src,
3012 SMDiagnostic &Error) {
3013 return MIParser(PFS, Error, Src).parseStandaloneRegister(Reg);
3014}
3015
Matthias Braun74ad41c2016-10-11 03:13:01 +00003016bool llvm::parseNamedRegisterReference(PerFunctionMIParsingState &PFS,
Matthias Braune35861d2016-07-13 23:27:50 +00003017 unsigned &Reg, StringRef Src,
Alex Lorenz9fab3702015-07-14 21:24:41 +00003018 SMDiagnostic &Error) {
Matthias Braune35861d2016-07-13 23:27:50 +00003019 return MIParser(PFS, Error, Src).parseStandaloneNamedRegister(Reg);
Alex Lorenz9fab3702015-07-14 21:24:41 +00003020}
Alex Lorenz12045a42015-07-27 17:42:45 +00003021
Matthias Braun74ad41c2016-10-11 03:13:01 +00003022bool llvm::parseVirtualRegisterReference(PerFunctionMIParsingState &PFS,
3023 VRegInfo *&Info, StringRef Src,
Alex Lorenz12045a42015-07-27 17:42:45 +00003024 SMDiagnostic &Error) {
Matthias Braun74ad41c2016-10-11 03:13:01 +00003025 return MIParser(PFS, Error, Src).parseStandaloneVirtualRegister(Info);
Alex Lorenz12045a42015-07-27 17:42:45 +00003026}
Alex Lorenza314d812015-08-18 22:26:26 +00003027
Matthias Braun74ad41c2016-10-11 03:13:01 +00003028bool llvm::parseStackObjectReference(PerFunctionMIParsingState &PFS,
Matthias Braune35861d2016-07-13 23:27:50 +00003029 int &FI, StringRef Src,
Alex Lorenza314d812015-08-18 22:26:26 +00003030 SMDiagnostic &Error) {
Matthias Braune35861d2016-07-13 23:27:50 +00003031 return MIParser(PFS, Error, Src).parseStandaloneStackObject(FI);
Alex Lorenza314d812015-08-18 22:26:26 +00003032}
Alex Lorenzdf9e3c62015-08-19 00:13:25 +00003033
Matthias Braun74ad41c2016-10-11 03:13:01 +00003034bool llvm::parseMDNode(PerFunctionMIParsingState &PFS,
Matthias Braune35861d2016-07-13 23:27:50 +00003035 MDNode *&Node, StringRef Src, SMDiagnostic &Error) {
3036 return MIParser(PFS, Error, Src).parseStandaloneMDNode(Node);
Alex Lorenzdf9e3c62015-08-19 00:13:25 +00003037}