blob: e1b43fee02f83c627849571ed2cdc2a62767988b [file] [log] [blame]
Alex Lorenz2bdb4e12015-05-27 18:02:19 +00001//===- MIRParser.cpp - MIR serialization format 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 Lorenz2bdb4e12015-05-27 18:02:19 +00006//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the class that parses the optional LLVM IR and machine
10// functions that are stored in MIR files.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/CodeGen/MIRParser/MIRParser.h"
Alex Lorenz33f0aef2015-06-26 16:46:11 +000015#include "llvm/ADT/DenseMap.h"
Alex Lorenz2bdb4e12015-05-27 18:02:19 +000016#include "llvm/ADT/STLExtras.h"
Quentin Colombet876ddf82016-04-08 16:40:43 +000017#include "llvm/ADT/StringMap.h"
18#include "llvm/ADT/StringRef.h"
Alex Lorenz2bdb4e12015-05-27 18:02:19 +000019#include "llvm/AsmParser/Parser.h"
Alex Lorenz5d6108e2015-06-26 22:56:48 +000020#include "llvm/AsmParser/SlotMapping.h"
Quentin Colombet876ddf82016-04-08 16:40:43 +000021#include "llvm/CodeGen/GlobalISel/RegisterBank.h"
22#include "llvm/CodeGen/GlobalISel/RegisterBankInfo.h"
Matt Arsenaultbc6d07c2019-03-14 22:54:43 +000023#include "llvm/CodeGen/MIRParser/MIParser.h"
Quentin Colombet876ddf82016-04-08 16:40:43 +000024#include "llvm/CodeGen/MIRYamlMapping.h"
Alex Lorenzab980492015-07-20 20:51:18 +000025#include "llvm/CodeGen/MachineConstantPool.h"
Alex Lorenz60541c12015-07-09 19:55:27 +000026#include "llvm/CodeGen/MachineFrameInfo.h"
Quentin Colombet876ddf82016-04-08 16:40:43 +000027#include "llvm/CodeGen/MachineFunction.h"
Alex Lorenzdf9e3c62015-08-19 00:13:25 +000028#include "llvm/CodeGen/MachineModuleInfo.h"
Alex Lorenz54565cf2015-06-24 19:56:10 +000029#include "llvm/CodeGen/MachineRegisterInfo.h"
Sander de Smalen5d6ee762019-06-17 09:13:29 +000030#include "llvm/CodeGen/TargetFrameLowering.h"
Alex Lorenz4f093bf2015-06-19 17:43:07 +000031#include "llvm/IR/BasicBlock.h"
Reid Kleckner28865802016-04-14 18:29:59 +000032#include "llvm/IR/DebugInfo.h"
Alex Lorenz735c47e2015-06-15 20:30:22 +000033#include "llvm/IR/DiagnosticInfo.h"
Alex Lorenz8e7a58d72015-06-15 23:07:38 +000034#include "llvm/IR/Instructions.h"
Alex Lorenz735c47e2015-06-15 20:30:22 +000035#include "llvm/IR/LLVMContext.h"
Alex Lorenz2bdb4e12015-05-27 18:02:19 +000036#include "llvm/IR/Module.h"
Alex Lorenz4f093bf2015-06-19 17:43:07 +000037#include "llvm/IR/ValueSymbolTable.h"
Alex Lorenz09b832c2015-05-29 17:05:41 +000038#include "llvm/Support/LineIterator.h"
Quentin Colombet876ddf82016-04-08 16:40:43 +000039#include "llvm/Support/MemoryBuffer.h"
Alex Lorenz2bdb4e12015-05-27 18:02:19 +000040#include "llvm/Support/SMLoc.h"
41#include "llvm/Support/SourceMgr.h"
Alex Lorenz2bdb4e12015-05-27 18:02:19 +000042#include "llvm/Support/YAMLTraits.h"
Matt Arsenaultbc6d07c2019-03-14 22:54:43 +000043#include "llvm/Target/TargetMachine.h"
Alex Lorenz2bdb4e12015-05-27 18:02:19 +000044#include <memory>
45
46using namespace llvm;
47
Alex Lorenz735c47e2015-06-15 20:30:22 +000048namespace llvm {
Alex Lorenz2bdb4e12015-05-27 18:02:19 +000049
50/// This class implements the parsing of LLVM IR that's embedded inside a MIR
51/// file.
52class MIRParserImpl {
53 SourceMgr SM;
Matthias Braun7bda1952017-06-06 00:44:35 +000054 yaml::Input In;
Alex Lorenz2bdb4e12015-05-27 18:02:19 +000055 StringRef Filename;
56 LLVMContext &Context;
Alex Lorenz5d6108e2015-06-26 22:56:48 +000057 SlotMapping IRSlots;
Matt Arsenaultbdfb6cf2019-03-12 20:42:12 +000058 std::unique_ptr<PerTargetMIParsingState> Target;
59
Matthias Braun7bda1952017-06-06 00:44:35 +000060 /// True when the MIR file doesn't have LLVM IR. Dummy IR functions are
61 /// created and inserted into the given module when this is true.
62 bool NoLLVMIR = false;
63 /// True when a well formed MIR file does not contain any MIR/machine function
64 /// parts.
65 bool NoMIRDocuments = false;
Alex Lorenz2bdb4e12015-05-27 18:02:19 +000066
67public:
Matthias Braun7bda1952017-06-06 00:44:35 +000068 MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents,
69 StringRef Filename, LLVMContext &Context);
Alex Lorenz2bdb4e12015-05-27 18:02:19 +000070
Alex Lorenz735c47e2015-06-15 20:30:22 +000071 void reportDiagnostic(const SMDiagnostic &Diag);
72
73 /// Report an error with the given message at unknown location.
74 ///
75 /// Always returns true.
76 bool error(const Twine &Message);
77
Alex Lorenzb1f9ce82015-07-08 20:22:20 +000078 /// Report an error with the given message at the given location.
79 ///
80 /// Always returns true.
81 bool error(SMLoc Loc, const Twine &Message);
82
Alex Lorenz0fd7c622015-06-30 17:55:00 +000083 /// Report a given error with the location translated from the location in an
84 /// embedded string literal to a location in the MIR file.
85 ///
86 /// Always returns true.
87 bool error(const SMDiagnostic &Error, SMRange SourceRange);
88
Alex Lorenz78d78312015-05-28 22:41:12 +000089 /// Try to parse the optional LLVM module and the machine functions in the MIR
90 /// file.
Alex Lorenz2bdb4e12015-05-27 18:02:19 +000091 ///
Alex Lorenz78d78312015-05-28 22:41:12 +000092 /// Return null if an error occurred.
Matthias Braun7bda1952017-06-06 00:44:35 +000093 std::unique_ptr<Module> parseIRModule();
94
95 bool parseMachineFunctions(Module &M, MachineModuleInfo &MMI);
Alex Lorenz78d78312015-05-28 22:41:12 +000096
97 /// Parse the machine function in the current YAML document.
98 ///
Alex Lorenz8e7a58d72015-06-15 23:07:38 +000099 ///
Alex Lorenz78d78312015-05-28 22:41:12 +0000100 /// Return true if an error occurred.
Matthias Braun7bda1952017-06-06 00:44:35 +0000101 bool parseMachineFunction(Module &M, MachineModuleInfo &MMI);
Alex Lorenz09b832c2015-05-29 17:05:41 +0000102
Alex Lorenz735c47e2015-06-15 20:30:22 +0000103 /// Initialize the machine function to the state that's described in the MIR
104 /// file.
105 ///
106 /// Return true if error occurred.
Matthias Braun7bda1952017-06-06 00:44:35 +0000107 bool initializeMachineFunction(const yaml::MachineFunction &YamlMF,
108 MachineFunction &MF);
Alex Lorenz735c47e2015-06-15 20:30:22 +0000109
Matthias Braun74ad41c2016-10-11 03:13:01 +0000110 bool parseRegisterInfo(PerFunctionMIParsingState &PFS,
111 const yaml::MachineFunction &YamlMF);
Alex Lorenz54565cf2015-06-24 19:56:10 +0000112
Matthias Braun74ad41c2016-10-11 03:13:01 +0000113 bool setupRegisterInfo(const PerFunctionMIParsingState &PFS,
Alex Lorenzc4838082015-08-11 00:32:49 +0000114 const yaml::MachineFunction &YamlMF);
115
Matthias Braun83947862016-07-13 22:23:23 +0000116 bool initializeFrameInfo(PerFunctionMIParsingState &PFS,
117 const yaml::MachineFunction &YamlMF);
Alex Lorenz1bb48de2015-07-24 22:22:50 +0000118
Matthias Braun83947862016-07-13 22:23:23 +0000119 bool parseCalleeSavedRegister(PerFunctionMIParsingState &PFS,
Alex Lorenz1bb48de2015-07-24 22:22:50 +0000120 std::vector<CalleeSavedInfo> &CSIInfo,
121 const yaml::StringValue &RegisterSource,
Matthias Braun5c3e8a42017-09-28 18:52:14 +0000122 bool IsRestored, int FrameIdx);
Alex Lorenz60541c12015-07-09 19:55:27 +0000123
Francis Visoiu Mistrih57fcd342018-04-25 18:58:06 +0000124 template <typename T>
Matthias Braun83947862016-07-13 22:23:23 +0000125 bool parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS,
Francis Visoiu Mistrih57fcd342018-04-25 18:58:06 +0000126 const T &Object,
Alex Lorenzdf9e3c62015-08-19 00:13:25 +0000127 int FrameIdx);
128
Matthias Braun83947862016-07-13 22:23:23 +0000129 bool initializeConstantPool(PerFunctionMIParsingState &PFS,
130 MachineConstantPool &ConstantPool,
131 const yaml::MachineFunction &YamlMF);
Alex Lorenzab980492015-07-20 20:51:18 +0000132
Matthias Braun83947862016-07-13 22:23:23 +0000133 bool initializeJumpTableInfo(PerFunctionMIParsingState &PFS,
134 const yaml::MachineJumpTable &YamlJTI);
Alex Lorenz6799e9b2015-07-15 23:31:07 +0000135
Alex Lorenz09b832c2015-05-29 17:05:41 +0000136private:
Matthias Braun74ad41c2016-10-11 03:13:01 +0000137 bool parseMDNode(PerFunctionMIParsingState &PFS, MDNode *&Node,
Matthias Braun83947862016-07-13 22:23:23 +0000138 const yaml::StringValue &Source);
Alex Lorenzdf9e3c62015-08-19 00:13:25 +0000139
Matthias Braun74ad41c2016-10-11 03:13:01 +0000140 bool parseMBBReference(PerFunctionMIParsingState &PFS,
Matthias Braun83947862016-07-13 22:23:23 +0000141 MachineBasicBlock *&MBB,
142 const yaml::StringValue &Source);
Alex Lorenz05fa73b2015-07-29 20:57:11 +0000143
Alex Lorenz51af1602015-06-23 22:39:23 +0000144 /// Return a MIR diagnostic converted from an MI string diagnostic.
145 SMDiagnostic diagFromMIStringDiag(const SMDiagnostic &Error,
146 SMRange SourceRange);
147
Alex Lorenz9b62cf62015-08-13 20:30:11 +0000148 /// Return a MIR diagnostic converted from a diagnostic located in a YAML
149 /// block scalar string.
150 SMDiagnostic diagFromBlockStringDiag(const SMDiagnostic &Error,
151 SMRange SourceRange);
Alex Lorenz8e7a58d72015-06-15 23:07:38 +0000152
Matthias Braun90799ce2016-08-23 21:19:49 +0000153 void computeFunctionProperties(MachineFunction &MF);
Alex Lorenz2bdb4e12015-05-27 18:02:19 +0000154};
155
Alex Lorenz735c47e2015-06-15 20:30:22 +0000156} // end namespace llvm
Alex Lorenz2bdb4e12015-05-27 18:02:19 +0000157
Matthias Braun7bda1952017-06-06 00:44:35 +0000158static void handleYAMLDiag(const SMDiagnostic &Diag, void *Context) {
159 reinterpret_cast<MIRParserImpl *>(Context)->reportDiagnostic(Diag);
160}
161
Alex Lorenz2bdb4e12015-05-27 18:02:19 +0000162MIRParserImpl::MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents,
163 StringRef Filename, LLVMContext &Context)
Matthias Braun7bda1952017-06-06 00:44:35 +0000164 : SM(),
165 In(SM.getMemoryBuffer(
166 SM.AddNewSourceBuffer(std::move(Contents), SMLoc()))->getBuffer(),
167 nullptr, handleYAMLDiag, this),
168 Filename(Filename),
169 Context(Context) {
170 In.setContext(&In);
Alex Lorenz2bdb4e12015-05-27 18:02:19 +0000171}
172
Alex Lorenz735c47e2015-06-15 20:30:22 +0000173bool MIRParserImpl::error(const Twine &Message) {
174 Context.diagnose(DiagnosticInfoMIRParser(
175 DS_Error, SMDiagnostic(Filename, SourceMgr::DK_Error, Message.str())));
176 return true;
Alex Lorenz78d78312015-05-28 22:41:12 +0000177}
Alex Lorenz2bdb4e12015-05-27 18:02:19 +0000178
Alex Lorenzb1f9ce82015-07-08 20:22:20 +0000179bool MIRParserImpl::error(SMLoc Loc, const Twine &Message) {
180 Context.diagnose(DiagnosticInfoMIRParser(
181 DS_Error, SM.GetMessage(Loc, SourceMgr::DK_Error, Message)));
182 return true;
183}
184
Alex Lorenz0fd7c622015-06-30 17:55:00 +0000185bool MIRParserImpl::error(const SMDiagnostic &Error, SMRange SourceRange) {
186 assert(Error.getKind() == SourceMgr::DK_Error && "Expected an error");
187 reportDiagnostic(diagFromMIStringDiag(Error, SourceRange));
188 return true;
189}
190
Alex Lorenz735c47e2015-06-15 20:30:22 +0000191void MIRParserImpl::reportDiagnostic(const SMDiagnostic &Diag) {
192 DiagnosticSeverity Kind;
193 switch (Diag.getKind()) {
194 case SourceMgr::DK_Error:
195 Kind = DS_Error;
196 break;
197 case SourceMgr::DK_Warning:
198 Kind = DS_Warning;
199 break;
200 case SourceMgr::DK_Note:
201 Kind = DS_Note;
202 break;
Adam Nemet01104ae2017-10-12 23:56:02 +0000203 case SourceMgr::DK_Remark:
204 llvm_unreachable("remark unexpected");
205 break;
Alex Lorenz735c47e2015-06-15 20:30:22 +0000206 }
207 Context.diagnose(DiagnosticInfoMIRParser(Kind, Diag));
208}
209
Matthias Braun7bda1952017-06-06 00:44:35 +0000210std::unique_ptr<Module> MIRParserImpl::parseIRModule() {
Alex Lorenz78d78312015-05-28 22:41:12 +0000211 if (!In.setCurrentDocument()) {
Alex Lorenz735c47e2015-06-15 20:30:22 +0000212 if (In.error())
Alex Lorenz78d78312015-05-28 22:41:12 +0000213 return nullptr;
214 // Create an empty module when the MIR file is empty.
Matthias Braun7bda1952017-06-06 00:44:35 +0000215 NoMIRDocuments = true;
Alex Lorenz78d78312015-05-28 22:41:12 +0000216 return llvm::make_unique<Module>(Filename, Context);
Alex Lorenz2bdb4e12015-05-27 18:02:19 +0000217 }
218
Alex Lorenz78d78312015-05-28 22:41:12 +0000219 std::unique_ptr<Module> M;
220 // Parse the block scalar manually so that we can return unique pointer
221 // without having to go trough YAML traits.
222 if (const auto *BSN =
223 dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) {
Alex Lorenz735c47e2015-06-15 20:30:22 +0000224 SMDiagnostic Error;
Alex Lorenz78d78312015-05-28 22:41:12 +0000225 M = parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error,
Yaxun Liuc00d81e2018-01-30 22:32:39 +0000226 Context, &IRSlots, /*UpgradeDebugInfo=*/false);
Alex Lorenz09b832c2015-05-29 17:05:41 +0000227 if (!M) {
Alex Lorenz9b62cf62015-08-13 20:30:11 +0000228 reportDiagnostic(diagFromBlockStringDiag(Error, BSN->getSourceRange()));
Matthias Braund6f95622016-07-14 00:42:37 +0000229 return nullptr;
Alex Lorenz09b832c2015-05-29 17:05:41 +0000230 }
Alex Lorenz78d78312015-05-28 22:41:12 +0000231 In.nextDocument();
232 if (!In.setCurrentDocument())
Matthias Braun7bda1952017-06-06 00:44:35 +0000233 NoMIRDocuments = true;
Alex Lorenz78d78312015-05-28 22:41:12 +0000234 } else {
235 // Create an new, empty module.
236 M = llvm::make_unique<Module>(Filename, Context);
Alex Lorenz8e7a58d72015-06-15 23:07:38 +0000237 NoLLVMIR = true;
Alex Lorenz78d78312015-05-28 22:41:12 +0000238 }
Alex Lorenz78d78312015-05-28 22:41:12 +0000239 return M;
240}
241
Matthias Braun7bda1952017-06-06 00:44:35 +0000242bool MIRParserImpl::parseMachineFunctions(Module &M, MachineModuleInfo &MMI) {
243 if (NoMIRDocuments)
244 return false;
245
246 // Parse the machine functions.
247 do {
248 if (parseMachineFunction(M, MMI))
249 return true;
250 In.nextDocument();
251 } while (In.setCurrentDocument());
252
Alex Lorenz735c47e2015-06-15 20:30:22 +0000253 return false;
254}
255
Matthias Braun7bda1952017-06-06 00:44:35 +0000256/// Create an empty function with the given name.
257static Function *createDummyFunction(StringRef Name, Module &M) {
Alex Lorenz8e7a58d72015-06-15 23:07:38 +0000258 auto &Context = M.getContext();
James Y Knight13680222019-02-01 02:28:03 +0000259 Function *F =
260 Function::Create(FunctionType::get(Type::getVoidTy(Context), false),
261 Function::ExternalLinkage, Name, M);
Alex Lorenz8e7a58d72015-06-15 23:07:38 +0000262 BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
263 new UnreachableInst(Context, BB);
Matthias Braun7bda1952017-06-06 00:44:35 +0000264 return F;
265}
266
267bool MIRParserImpl::parseMachineFunction(Module &M, MachineModuleInfo &MMI) {
268 // Parse the yaml.
269 yaml::MachineFunction YamlMF;
270 yaml::EmptyContext Ctx;
Matt Arsenaultbc6d07c2019-03-14 22:54:43 +0000271
272 const LLVMTargetMachine &TM = MMI.getTarget();
273 YamlMF.MachineFuncInfo = std::unique_ptr<yaml::MachineFunctionInfo>(
274 TM.createDefaultFuncInfoYAML());
275
Matthias Braun7bda1952017-06-06 00:44:35 +0000276 yaml::yamlize(In, YamlMF, false, Ctx);
277 if (In.error())
278 return true;
279
280 // Search for the corresponding IR function.
281 StringRef FunctionName = YamlMF.Name;
282 Function *F = M.getFunction(FunctionName);
283 if (!F) {
284 if (NoLLVMIR) {
285 F = createDummyFunction(FunctionName, M);
286 } else {
287 return error(Twine("function '") + FunctionName +
288 "' isn't defined in the provided LLVM IR");
289 }
290 }
291 if (MMI.getMachineFunction(*F) != nullptr)
292 return error(Twine("redefinition of machine function '") + FunctionName +
293 "'");
294
295 // Create the MachineFunction.
296 MachineFunction &MF = MMI.getOrCreateMachineFunction(*F);
297 if (initializeMachineFunction(YamlMF, MF))
298 return true;
299
300 return false;
Alex Lorenz8e7a58d72015-06-15 23:07:38 +0000301}
302
Matthias Braun79f85b32016-08-24 01:32:41 +0000303static bool isSSA(const MachineFunction &MF) {
304 const MachineRegisterInfo &MRI = MF.getRegInfo();
305 for (unsigned I = 0, E = MRI.getNumVirtRegs(); I != E; ++I) {
306 unsigned Reg = TargetRegisterInfo::index2VirtReg(I);
307 if (!MRI.hasOneDef(Reg) && !MRI.def_empty(Reg))
308 return false;
309 }
310 return true;
311}
312
Matthias Braun90799ce2016-08-23 21:19:49 +0000313void MIRParserImpl::computeFunctionProperties(MachineFunction &MF) {
Matthias Braun79f85b32016-08-24 01:32:41 +0000314 MachineFunctionProperties &Properties = MF.getProperties();
Matthias Brauna319e2c2016-08-24 22:34:06 +0000315
316 bool HasPHI = false;
317 bool HasInlineAsm = false;
318 for (const MachineBasicBlock &MBB : MF) {
319 for (const MachineInstr &MI : MBB) {
320 if (MI.isPHI())
321 HasPHI = true;
322 if (MI.isInlineAsm())
323 HasInlineAsm = true;
324 }
325 }
326 if (!HasPHI)
Matthias Braun79f85b32016-08-24 01:32:41 +0000327 Properties.set(MachineFunctionProperties::Property::NoPHIs);
Matthias Brauna319e2c2016-08-24 22:34:06 +0000328 MF.setHasInlineAsm(HasInlineAsm);
Matthias Braun79f85b32016-08-24 01:32:41 +0000329
330 if (isSSA(MF))
331 Properties.set(MachineFunctionProperties::Property::IsSSA);
332 else
Quentin Colombete609a9a2016-08-26 22:09:11 +0000333 Properties.reset(MachineFunctionProperties::Property::IsSSA);
Matthias Braun1eb47362016-08-25 01:27:13 +0000334
335 const MachineRegisterInfo &MRI = MF.getRegInfo();
336 if (MRI.getNumVirtRegs() == 0)
337 Properties.set(MachineFunctionProperties::Property::NoVRegs);
Matthias Braun90799ce2016-08-23 21:19:49 +0000338}
339
Matthias Braun7bda1952017-06-06 00:44:35 +0000340bool
341MIRParserImpl::initializeMachineFunction(const yaml::MachineFunction &YamlMF,
342 MachineFunction &MF) {
Alex Lorenz735c47e2015-06-15 20:30:22 +0000343 // TODO: Recreate the machine function.
Matt Arsenaultbdfb6cf2019-03-12 20:42:12 +0000344 if (Target) {
345 // Avoid clearing state if we're using the same subtarget again.
346 Target->setTarget(MF.getSubtarget());
347 } else {
348 Target.reset(new PerTargetMIParsingState(MF.getSubtarget()));
349 }
350
Alex Lorenz5b5f9752015-06-16 00:10:47 +0000351 if (YamlMF.Alignment)
352 MF.setAlignment(YamlMF.Alignment);
353 MF.setExposesReturnsTwice(YamlMF.ExposesReturnsTwice);
Sanjin Sijaric625d08e2018-10-24 21:07:38 +0000354 MF.setHasWinCFI(YamlMF.HasWinCFI);
Ahmed Bougacha0d7b0cb2016-08-02 15:10:25 +0000355
356 if (YamlMF.Legalized)
357 MF.getProperties().set(MachineFunctionProperties::Property::Legalized);
Ahmed Bougacha24712652016-08-02 16:17:10 +0000358 if (YamlMF.RegBankSelected)
359 MF.getProperties().set(
360 MachineFunctionProperties::Property::RegBankSelected);
Ahmed Bougachab109d512016-08-02 16:49:19 +0000361 if (YamlMF.Selected)
362 MF.getProperties().set(MachineFunctionProperties::Property::Selected);
Roman Tereshin3054ece2018-02-28 17:55:45 +0000363 if (YamlMF.FailedISel)
364 MF.getProperties().set(MachineFunctionProperties::Property::FailedISel);
Ahmed Bougacha0d7b0cb2016-08-02 15:10:25 +0000365
Matt Arsenaultbdfb6cf2019-03-12 20:42:12 +0000366 PerFunctionMIParsingState PFS(MF, SM, IRSlots, *Target);
Matthias Braun74ad41c2016-10-11 03:13:01 +0000367 if (parseRegisterInfo(PFS, YamlMF))
Alex Lorenz54565cf2015-06-24 19:56:10 +0000368 return true;
Alex Lorenzab980492015-07-20 20:51:18 +0000369 if (!YamlMF.Constants.empty()) {
370 auto *ConstantPool = MF.getConstantPool();
371 assert(ConstantPool && "Constant pool must be created");
Matthias Braun83947862016-07-13 22:23:23 +0000372 if (initializeConstantPool(PFS, *ConstantPool, YamlMF))
Alex Lorenzab980492015-07-20 20:51:18 +0000373 return true;
374 }
Alex Lorenz54565cf2015-06-24 19:56:10 +0000375
Matthias Braune35861d2016-07-13 23:27:50 +0000376 StringRef BlockStr = YamlMF.Body.Value.Value;
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000377 SMDiagnostic Error;
Matthias Braune35861d2016-07-13 23:27:50 +0000378 SourceMgr BlockSM;
379 BlockSM.AddNewSourceBuffer(
380 MemoryBuffer::getMemBuffer(BlockStr, "",/*RequiresNullTerminator=*/false),
381 SMLoc());
382 PFS.SM = &BlockSM;
383 if (parseMachineBasicBlockDefinitions(PFS, BlockStr, Error)) {
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000384 reportDiagnostic(
385 diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange));
386 return true;
Alex Lorenz33f0aef2015-06-26 16:46:11 +0000387 }
Matthias Braune35861d2016-07-13 23:27:50 +0000388 PFS.SM = &SM;
Alex Lorenz33f0aef2015-06-26 16:46:11 +0000389
Alex Lorenza6f9a372015-07-29 21:09:09 +0000390 // Initialize the frame information after creating all the MBBs so that the
391 // MBB references in the frame information can be resolved.
Matthias Braun83947862016-07-13 22:23:23 +0000392 if (initializeFrameInfo(PFS, YamlMF))
Alex Lorenza6f9a372015-07-29 21:09:09 +0000393 return true;
Alex Lorenz6799e9b2015-07-15 23:31:07 +0000394 // Initialize the jump table after creating all the MBBs so that the MBB
395 // references can be resolved.
396 if (!YamlMF.JumpTableInfo.Entries.empty() &&
Matthias Braun83947862016-07-13 22:23:23 +0000397 initializeJumpTableInfo(PFS, YamlMF.JumpTableInfo))
Alex Lorenz6799e9b2015-07-15 23:31:07 +0000398 return true;
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000399 // Parse the machine instructions after creating all of the MBBs so that the
400 // parser can resolve the MBB references.
Matthias Braune35861d2016-07-13 23:27:50 +0000401 StringRef InsnStr = YamlMF.Body.Value.Value;
402 SourceMgr InsnSM;
403 InsnSM.AddNewSourceBuffer(
404 MemoryBuffer::getMemBuffer(InsnStr, "", /*RequiresNullTerminator=*/false),
405 SMLoc());
406 PFS.SM = &InsnSM;
407 if (parseMachineInstructions(PFS, InsnStr, Error)) {
Alex Lorenz5022f6b2015-08-13 23:10:16 +0000408 reportDiagnostic(
409 diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange));
410 return true;
Alex Lorenz4f093bf2015-06-19 17:43:07 +0000411 }
Matthias Braune35861d2016-07-13 23:27:50 +0000412 PFS.SM = &SM;
413
Matthias Braun74ad41c2016-10-11 03:13:01 +0000414 if (setupRegisterInfo(PFS, YamlMF))
415 return true;
Matthias Braun90799ce2016-08-23 21:19:49 +0000416
Matt Arsenaultbc6d07c2019-03-14 22:54:43 +0000417 if (YamlMF.MachineFuncInfo) {
418 const LLVMTargetMachine &TM = MF.getTarget();
419 // Note this is called after the initial constructor of the
420 // MachineFunctionInfo based on the MachineFunction, which may depend on the
421 // IR.
422
423 SMRange SrcRange;
424 if (TM.parseMachineFunctionInfo(*YamlMF.MachineFuncInfo, PFS, Error,
425 SrcRange)) {
426 return error(Error, SrcRange);
427 }
428 }
429
Matt Arsenault733b8572019-03-27 16:12:26 +0000430 // Set the reserved registers after parsing MachineFuncInfo. The target may
431 // have been recording information used to select the reserved registers
432 // there.
433 // FIXME: This is a temporary workaround until the reserved registers can be
434 // serialized.
435 MachineRegisterInfo &MRI = MF.getRegInfo();
436 MRI.freezeReservedRegs(MF);
437
Matthias Braun90799ce2016-08-23 21:19:49 +0000438 computeFunctionProperties(MF);
439
Matthias Braun5c290dc2018-01-19 03:16:36 +0000440 MF.getSubtarget().mirFileLoaded(MF);
441
Alex Lorenzc7bf2042015-07-24 17:44:49 +0000442 MF.verify();
Alex Lorenz4f093bf2015-06-19 17:43:07 +0000443 return false;
444}
445
Matthias Braun74ad41c2016-10-11 03:13:01 +0000446bool MIRParserImpl::parseRegisterInfo(PerFunctionMIParsingState &PFS,
447 const yaml::MachineFunction &YamlMF) {
Matthias Braun83947862016-07-13 22:23:23 +0000448 MachineFunction &MF = PFS.MF;
Alex Lorenzdb07c402015-07-28 16:48:37 +0000449 MachineRegisterInfo &RegInfo = MF.getRegInfo();
Alex Lorenz54565cf2015-06-24 19:56:10 +0000450 assert(RegInfo.tracksLiveness());
451 if (!YamlMF.TracksRegLiveness)
452 RegInfo.invalidateLiveness();
Alex Lorenz28148ba2015-07-09 22:23:13 +0000453
Alex Lorenzab4cbcf2015-07-24 20:35:40 +0000454 SMDiagnostic Error;
Alex Lorenz28148ba2015-07-09 22:23:13 +0000455 // Parse the virtual register information.
456 for (const auto &VReg : YamlMF.VirtualRegisters) {
Matthias Braun74ad41c2016-10-11 03:13:01 +0000457 VRegInfo &Info = PFS.getVRegInfo(VReg.ID.Value);
458 if (Info.Explicit)
459 return error(VReg.ID.SourceRange.Start,
460 Twine("redefinition of virtual register '%") +
461 Twine(VReg.ID.Value) + "'");
462 Info.Explicit = true;
463
Quentin Colombet050b2112016-03-08 01:17:03 +0000464 if (StringRef(VReg.Class.Value).equals("_")) {
Matthias Braun74ad41c2016-10-11 03:13:01 +0000465 Info.Kind = VRegInfo::GENERIC;
Justin Bogner6c7663f2017-11-17 18:51:20 +0000466 Info.D.RegBank = nullptr;
Quentin Colombet050b2112016-03-08 01:17:03 +0000467 } else {
Matt Arsenaultbdfb6cf2019-03-12 20:42:12 +0000468 const auto *RC = Target->getRegClass(VReg.Class.Value);
Quentin Colombet876ddf82016-04-08 16:40:43 +0000469 if (RC) {
Matthias Braun74ad41c2016-10-11 03:13:01 +0000470 Info.Kind = VRegInfo::NORMAL;
471 Info.D.RC = RC;
Quentin Colombet876ddf82016-04-08 16:40:43 +0000472 } else {
Matt Arsenaultbdfb6cf2019-03-12 20:42:12 +0000473 const RegisterBank *RegBank = Target->getRegBank(VReg.Class.Value);
Quentin Colombet876ddf82016-04-08 16:40:43 +0000474 if (!RegBank)
475 return error(
476 VReg.Class.SourceRange.Start,
477 Twine("use of undefined register class or register bank '") +
478 VReg.Class.Value + "'");
Matthias Braun74ad41c2016-10-11 03:13:01 +0000479 Info.Kind = VRegInfo::REGBANK;
480 Info.D.RegBank = RegBank;
Quentin Colombet876ddf82016-04-08 16:40:43 +0000481 }
Quentin Colombet050b2112016-03-08 01:17:03 +0000482 }
Matthias Braun74ad41c2016-10-11 03:13:01 +0000483
Alex Lorenzab4cbcf2015-07-24 20:35:40 +0000484 if (!VReg.PreferredRegister.Value.empty()) {
Matthias Braun74ad41c2016-10-11 03:13:01 +0000485 if (Info.Kind != VRegInfo::NORMAL)
486 return error(VReg.Class.SourceRange.Start,
487 Twine("preferred register can only be set for normal vregs"));
Tom Stellard9c884e42016-11-15 00:03:14 +0000488
489 if (parseRegisterReference(PFS, Info.PreferredReg,
490 VReg.PreferredRegister.Value, Error))
Alex Lorenzab4cbcf2015-07-24 20:35:40 +0000491 return error(Error, VReg.PreferredRegister.SourceRange);
Alex Lorenzab4cbcf2015-07-24 20:35:40 +0000492 }
Alex Lorenz28148ba2015-07-09 22:23:13 +0000493 }
Alex Lorenz12045a42015-07-27 17:42:45 +0000494
495 // Parse the liveins.
496 for (const auto &LiveIn : YamlMF.LiveIns) {
497 unsigned Reg = 0;
Matthias Braune35861d2016-07-13 23:27:50 +0000498 if (parseNamedRegisterReference(PFS, Reg, LiveIn.Register.Value, Error))
Alex Lorenz12045a42015-07-27 17:42:45 +0000499 return error(Error, LiveIn.Register.SourceRange);
500 unsigned VReg = 0;
501 if (!LiveIn.VirtualRegister.Value.empty()) {
Matthias Braun74ad41c2016-10-11 03:13:01 +0000502 VRegInfo *Info;
503 if (parseVirtualRegisterReference(PFS, Info, LiveIn.VirtualRegister.Value,
Matthias Braune35861d2016-07-13 23:27:50 +0000504 Error))
Alex Lorenz12045a42015-07-27 17:42:45 +0000505 return error(Error, LiveIn.VirtualRegister.SourceRange);
Matthias Braun74ad41c2016-10-11 03:13:01 +0000506 VReg = Info->VReg;
Alex Lorenz12045a42015-07-27 17:42:45 +0000507 }
508 RegInfo.addLiveIn(Reg, VReg);
509 }
Alex Lorenzc4838082015-08-11 00:32:49 +0000510
Oren Ben Simhon0ef61ec2017-03-19 08:14:18 +0000511 // Parse the callee saved registers (Registers that will
512 // be saved for the caller).
513 if (YamlMF.CalleeSavedRegisters) {
514 SmallVector<MCPhysReg, 16> CalleeSavedRegisters;
515 for (const auto &RegSource : YamlMF.CalleeSavedRegisters.getValue()) {
516 unsigned Reg = 0;
517 if (parseNamedRegisterReference(PFS, Reg, RegSource.Value, Error))
518 return error(Error, RegSource.SourceRange);
519 CalleeSavedRegisters.push_back(Reg);
520 }
521 RegInfo.setCalleeSavedRegs(CalleeSavedRegisters);
Alex Lorenzc4838082015-08-11 00:32:49 +0000522 }
Oren Ben Simhon0ef61ec2017-03-19 08:14:18 +0000523
Alex Lorenz54565cf2015-06-24 19:56:10 +0000524 return false;
525}
526
Matthias Braun74ad41c2016-10-11 03:13:01 +0000527bool MIRParserImpl::setupRegisterInfo(const PerFunctionMIParsingState &PFS,
Alex Lorenzc4838082015-08-11 00:32:49 +0000528 const yaml::MachineFunction &YamlMF) {
Matthias Braun74ad41c2016-10-11 03:13:01 +0000529 MachineFunction &MF = PFS.MF;
530 MachineRegisterInfo &MRI = MF.getRegInfo();
531 bool Error = false;
532 // Create VRegs
Puyan Lotfi399b46c2018-03-30 18:15:54 +0000533 auto populateVRegInfo = [&] (const VRegInfo &Info, Twine Name) {
Matthias Braun74ad41c2016-10-11 03:13:01 +0000534 unsigned Reg = Info.VReg;
535 switch (Info.Kind) {
536 case VRegInfo::UNKNOWN:
537 error(Twine("Cannot determine class/bank of virtual register ") +
Puyan Lotfi399b46c2018-03-30 18:15:54 +0000538 Name + " in function '" + MF.getName() + "'");
Matthias Braun74ad41c2016-10-11 03:13:01 +0000539 Error = true;
540 break;
541 case VRegInfo::NORMAL:
542 MRI.setRegClass(Reg, Info.D.RC);
543 if (Info.PreferredReg != 0)
544 MRI.setSimpleHint(Reg, Info.PreferredReg);
545 break;
546 case VRegInfo::GENERIC:
547 break;
548 case VRegInfo::REGBANK:
549 MRI.setRegBank(Reg, *Info.D.RegBank);
550 break;
551 }
Puyan Lotfi399b46c2018-03-30 18:15:54 +0000552 };
553
554 for (auto I = PFS.VRegInfosNamed.begin(), E = PFS.VRegInfosNamed.end();
555 I != E; I++) {
556 const VRegInfo &Info = *I->second;
557 populateVRegInfo(Info, Twine(I->first()));
558 }
559
560 for (auto P : PFS.VRegInfos) {
561 const VRegInfo &Info = *P.second;
562 populateVRegInfo(Info, Twine(P.first));
Matthias Braun74ad41c2016-10-11 03:13:01 +0000563 }
564
565 // Compute MachineRegisterInfo::UsedPhysRegMask
Oren Ben Simhon0ef61ec2017-03-19 08:14:18 +0000566 for (const MachineBasicBlock &MBB : MF) {
567 for (const MachineInstr &MI : MBB) {
568 for (const MachineOperand &MO : MI.operands()) {
569 if (!MO.isRegMask())
570 continue;
571 MRI.addPhysRegsUsedFromRegMask(MO.getRegMask());
Alex Lorenzc4838082015-08-11 00:32:49 +0000572 }
573 }
574 }
Matthias Braun74ad41c2016-10-11 03:13:01 +0000575
Matthias Braun74ad41c2016-10-11 03:13:01 +0000576 return Error;
Alex Lorenzc4838082015-08-11 00:32:49 +0000577}
578
Matthias Braun83947862016-07-13 22:23:23 +0000579bool MIRParserImpl::initializeFrameInfo(PerFunctionMIParsingState &PFS,
580 const yaml::MachineFunction &YamlMF) {
581 MachineFunction &MF = PFS.MF;
Matthias Braun941a7052016-07-28 18:40:00 +0000582 MachineFrameInfo &MFI = MF.getFrameInfo();
Sander de Smalen5d6ee762019-06-17 09:13:29 +0000583 const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
Matthias Braunf1caa282017-12-15 22:22:58 +0000584 const Function &F = MF.getFunction();
Alex Lorenzf6bc8662015-07-10 18:13:57 +0000585 const yaml::MachineFrameInfo &YamlMFI = YamlMF.FrameInfo;
Alex Lorenz60541c12015-07-09 19:55:27 +0000586 MFI.setFrameAddressIsTaken(YamlMFI.IsFrameAddressTaken);
587 MFI.setReturnAddressIsTaken(YamlMFI.IsReturnAddressTaken);
588 MFI.setHasStackMap(YamlMFI.HasStackMap);
589 MFI.setHasPatchPoint(YamlMFI.HasPatchPoint);
590 MFI.setStackSize(YamlMFI.StackSize);
591 MFI.setOffsetAdjustment(YamlMFI.OffsetAdjustment);
592 if (YamlMFI.MaxAlignment)
593 MFI.ensureMaxAlignment(YamlMFI.MaxAlignment);
594 MFI.setAdjustsStack(YamlMFI.AdjustsStack);
595 MFI.setHasCalls(YamlMFI.HasCalls);
Matthias Braunab9438c2017-05-01 22:32:25 +0000596 if (YamlMFI.MaxCallFrameSize != ~0u)
597 MFI.setMaxCallFrameSize(YamlMFI.MaxCallFrameSize);
Reid Kleckner9ea2c012018-10-01 21:59:45 +0000598 MFI.setCVBytesOfCalleeSavedRegisters(YamlMFI.CVBytesOfCalleeSavedRegisters);
Alex Lorenz60541c12015-07-09 19:55:27 +0000599 MFI.setHasOpaqueSPAdjustment(YamlMFI.HasOpaqueSPAdjustment);
600 MFI.setHasVAStart(YamlMFI.HasVAStart);
601 MFI.setHasMustTailInVarArgFunc(YamlMFI.HasMustTailInVarArgFunc);
Francis Visoiu Mistrih537d7ee2018-04-06 08:56:25 +0000602 MFI.setLocalFrameSize(YamlMFI.LocalFrameSize);
Alex Lorenza6f9a372015-07-29 21:09:09 +0000603 if (!YamlMFI.SavePoint.Value.empty()) {
604 MachineBasicBlock *MBB = nullptr;
Matthias Braun83947862016-07-13 22:23:23 +0000605 if (parseMBBReference(PFS, MBB, YamlMFI.SavePoint))
Alex Lorenza6f9a372015-07-29 21:09:09 +0000606 return true;
607 MFI.setSavePoint(MBB);
608 }
609 if (!YamlMFI.RestorePoint.Value.empty()) {
610 MachineBasicBlock *MBB = nullptr;
Matthias Braun83947862016-07-13 22:23:23 +0000611 if (parseMBBReference(PFS, MBB, YamlMFI.RestorePoint))
Alex Lorenza6f9a372015-07-29 21:09:09 +0000612 return true;
613 MFI.setRestorePoint(MBB);
614 }
Alex Lorenzf6bc8662015-07-10 18:13:57 +0000615
Alex Lorenz1bb48de2015-07-24 22:22:50 +0000616 std::vector<CalleeSavedInfo> CSIInfo;
Alex Lorenzde491f02015-07-13 18:07:26 +0000617 // Initialize the fixed frame objects.
618 for (const auto &Object : YamlMF.FixedStackObjects) {
619 int ObjectIdx;
620 if (Object.Type != yaml::FixedMachineStackObject::SpillSlot)
621 ObjectIdx = MFI.CreateFixedObject(Object.Size, Object.Offset,
622 Object.IsImmutable, Object.IsAliased);
623 else
624 ObjectIdx = MFI.CreateFixedSpillStackObject(Object.Size, Object.Offset);
Sander de Smalen5d6ee762019-06-17 09:13:29 +0000625
626 if (!TFI->isSupportedStackID(Object.StackID))
627 return error(Object.ID.SourceRange.Start,
628 Twine("StackID is not supported by target"));
Matt Arsenaultdb782732017-07-20 21:03:45 +0000629 MFI.setStackID(ObjectIdx, Object.StackID);
Sander de Smalen7f23e0a2019-04-02 09:46:52 +0000630 MFI.setObjectAlignment(ObjectIdx, Object.Alignment);
Alex Lorenz1d9a3032015-08-10 23:45:02 +0000631 if (!PFS.FixedStackObjectSlots.insert(std::make_pair(Object.ID.Value,
632 ObjectIdx))
633 .second)
634 return error(Object.ID.SourceRange.Start,
635 Twine("redefinition of fixed stack object '%fixed-stack.") +
636 Twine(Object.ID.Value) + "'");
Matthias Braun83947862016-07-13 22:23:23 +0000637 if (parseCalleeSavedRegister(PFS, CSIInfo, Object.CalleeSavedRegister,
Matthias Braun5c3e8a42017-09-28 18:52:14 +0000638 Object.CalleeSavedRestored, ObjectIdx))
Alex Lorenz1bb48de2015-07-24 22:22:50 +0000639 return true;
Francis Visoiu Mistrih57fcd342018-04-25 18:58:06 +0000640 if (parseStackObjectsDebugInfo(PFS, Object, ObjectIdx))
641 return true;
Alex Lorenzde491f02015-07-13 18:07:26 +0000642 }
643
644 // Initialize the ordinary frame objects.
Alex Lorenzf6bc8662015-07-10 18:13:57 +0000645 for (const auto &Object : YamlMF.StackObjects) {
Alex Lorenz418f3ec2015-07-14 00:26:26 +0000646 int ObjectIdx;
Alex Lorenz37643a02015-07-15 22:14:49 +0000647 const AllocaInst *Alloca = nullptr;
648 const yaml::StringValue &Name = Object.Name;
649 if (!Name.Value.empty()) {
650 Alloca = dyn_cast_or_null<AllocaInst>(
Mehdi Aminia53d49e2016-09-17 06:00:02 +0000651 F.getValueSymbolTable()->lookup(Name.Value));
Alex Lorenz37643a02015-07-15 22:14:49 +0000652 if (!Alloca)
653 return error(Name.SourceRange.Start,
654 "alloca instruction named '" + Name.Value +
655 "' isn't defined in the function '" + F.getName() +
656 "'");
657 }
Sander de Smalen5d6ee762019-06-17 09:13:29 +0000658 if (!TFI->isSupportedStackID(Object.StackID))
659 return error(Object.ID.SourceRange.Start,
660 Twine("StackID is not supported by target"));
Alex Lorenz418f3ec2015-07-14 00:26:26 +0000661 if (Object.Type == yaml::MachineStackObject::VariableSized)
Alex Lorenz37643a02015-07-15 22:14:49 +0000662 ObjectIdx = MFI.CreateVariableSizedObject(Object.Alignment, Alloca);
Alex Lorenz418f3ec2015-07-14 00:26:26 +0000663 else
664 ObjectIdx = MFI.CreateStackObject(
665 Object.Size, Object.Alignment,
Sander de Smalen7f23e0a2019-04-02 09:46:52 +0000666 Object.Type == yaml::MachineStackObject::SpillSlot, Alloca,
667 Object.StackID);
Alex Lorenzf6bc8662015-07-10 18:13:57 +0000668 MFI.setObjectOffset(ObjectIdx, Object.Offset);
Matt Arsenaultdb782732017-07-20 21:03:45 +0000669
Alex Lorenzc5d35ba2015-08-10 23:50:41 +0000670 if (!PFS.StackObjectSlots.insert(std::make_pair(Object.ID.Value, ObjectIdx))
671 .second)
672 return error(Object.ID.SourceRange.Start,
673 Twine("redefinition of stack object '%stack.") +
674 Twine(Object.ID.Value) + "'");
Matthias Braun83947862016-07-13 22:23:23 +0000675 if (parseCalleeSavedRegister(PFS, CSIInfo, Object.CalleeSavedRegister,
Matthias Braun5c3e8a42017-09-28 18:52:14 +0000676 Object.CalleeSavedRestored, ObjectIdx))
Alex Lorenz1bb48de2015-07-24 22:22:50 +0000677 return true;
Alex Lorenza56ba6a2015-08-17 22:17:42 +0000678 if (Object.LocalOffset)
679 MFI.mapLocalFrameObject(ObjectIdx, Object.LocalOffset.getValue());
Matthias Braun83947862016-07-13 22:23:23 +0000680 if (parseStackObjectsDebugInfo(PFS, Object, ObjectIdx))
Alex Lorenzdf9e3c62015-08-19 00:13:25 +0000681 return true;
Alex Lorenzf6bc8662015-07-10 18:13:57 +0000682 }
Alex Lorenz1bb48de2015-07-24 22:22:50 +0000683 MFI.setCalleeSavedInfo(CSIInfo);
684 if (!CSIInfo.empty())
685 MFI.setCalleeSavedInfoValid(true);
Alex Lorenza314d812015-08-18 22:26:26 +0000686
687 // Initialize the various stack object references after initializing the
688 // stack objects.
689 if (!YamlMFI.StackProtector.Value.empty()) {
690 SMDiagnostic Error;
691 int FI;
Matthias Braune35861d2016-07-13 23:27:50 +0000692 if (parseStackObjectReference(PFS, FI, YamlMFI.StackProtector.Value, Error))
Alex Lorenza314d812015-08-18 22:26:26 +0000693 return error(Error, YamlMFI.StackProtector.SourceRange);
694 MFI.setStackProtectorIndex(FI);
695 }
Alex Lorenz1bb48de2015-07-24 22:22:50 +0000696 return false;
697}
698
Matthias Braun83947862016-07-13 22:23:23 +0000699bool MIRParserImpl::parseCalleeSavedRegister(PerFunctionMIParsingState &PFS,
Alex Lorenz1bb48de2015-07-24 22:22:50 +0000700 std::vector<CalleeSavedInfo> &CSIInfo,
Matthias Braun5c3e8a42017-09-28 18:52:14 +0000701 const yaml::StringValue &RegisterSource, bool IsRestored, int FrameIdx) {
Alex Lorenz1bb48de2015-07-24 22:22:50 +0000702 if (RegisterSource.Value.empty())
703 return false;
704 unsigned Reg = 0;
705 SMDiagnostic Error;
Matthias Braune35861d2016-07-13 23:27:50 +0000706 if (parseNamedRegisterReference(PFS, Reg, RegisterSource.Value, Error))
Alex Lorenz1bb48de2015-07-24 22:22:50 +0000707 return error(Error, RegisterSource.SourceRange);
Matthias Braun5c3e8a42017-09-28 18:52:14 +0000708 CalleeSavedInfo CSI(Reg, FrameIdx);
709 CSI.setRestored(IsRestored);
710 CSIInfo.push_back(CSI);
Alex Lorenz60541c12015-07-09 19:55:27 +0000711 return false;
712}
713
Alex Lorenzdf9e3c62015-08-19 00:13:25 +0000714/// Verify that given node is of a certain type. Return true on error.
715template <typename T>
716static bool typecheckMDNode(T *&Result, MDNode *Node,
717 const yaml::StringValue &Source,
718 StringRef TypeString, MIRParserImpl &Parser) {
719 if (!Node)
720 return false;
721 Result = dyn_cast<T>(Node);
722 if (!Result)
723 return Parser.error(Source.SourceRange.Start,
724 "expected a reference to a '" + TypeString +
725 "' metadata node");
726 return false;
727}
728
Francis Visoiu Mistrih57fcd342018-04-25 18:58:06 +0000729template <typename T>
Matthias Braun83947862016-07-13 22:23:23 +0000730bool MIRParserImpl::parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS,
Francis Visoiu Mistrih57fcd342018-04-25 18:58:06 +0000731 const T &Object, int FrameIdx) {
Alex Lorenzdf9e3c62015-08-19 00:13:25 +0000732 // Debug information can only be attached to stack objects; Fixed stack
733 // objects aren't supported.
Alex Lorenzdf9e3c62015-08-19 00:13:25 +0000734 MDNode *Var = nullptr, *Expr = nullptr, *Loc = nullptr;
Matthias Braun83947862016-07-13 22:23:23 +0000735 if (parseMDNode(PFS, Var, Object.DebugVar) ||
736 parseMDNode(PFS, Expr, Object.DebugExpr) ||
737 parseMDNode(PFS, Loc, Object.DebugLoc))
Alex Lorenzdf9e3c62015-08-19 00:13:25 +0000738 return true;
739 if (!Var && !Expr && !Loc)
740 return false;
741 DILocalVariable *DIVar = nullptr;
742 DIExpression *DIExpr = nullptr;
743 DILocation *DILoc = nullptr;
744 if (typecheckMDNode(DIVar, Var, Object.DebugVar, "DILocalVariable", *this) ||
745 typecheckMDNode(DIExpr, Expr, Object.DebugExpr, "DIExpression", *this) ||
746 typecheckMDNode(DILoc, Loc, Object.DebugLoc, "DILocation", *this))
747 return true;
Francis Visoiu Mistrih57fcd342018-04-25 18:58:06 +0000748 PFS.MF.setVariableDbgInfo(DIVar, DIExpr, FrameIdx, DILoc);
Alex Lorenzdf9e3c62015-08-19 00:13:25 +0000749 return false;
750}
751
Matthias Braun74ad41c2016-10-11 03:13:01 +0000752bool MIRParserImpl::parseMDNode(PerFunctionMIParsingState &PFS,
Matthias Braun83947862016-07-13 22:23:23 +0000753 MDNode *&Node, const yaml::StringValue &Source) {
Alex Lorenzdf9e3c62015-08-19 00:13:25 +0000754 if (Source.Value.empty())
755 return false;
756 SMDiagnostic Error;
Matthias Braune35861d2016-07-13 23:27:50 +0000757 if (llvm::parseMDNode(PFS, Node, Source.Value, Error))
Alex Lorenzdf9e3c62015-08-19 00:13:25 +0000758 return error(Error, Source.SourceRange);
759 return false;
760}
761
Matthias Braun83947862016-07-13 22:23:23 +0000762bool MIRParserImpl::initializeConstantPool(PerFunctionMIParsingState &PFS,
763 MachineConstantPool &ConstantPool, const yaml::MachineFunction &YamlMF) {
764 DenseMap<unsigned, unsigned> &ConstantPoolSlots = PFS.ConstantPoolSlots;
765 const MachineFunction &MF = PFS.MF;
Matthias Braunf1caa282017-12-15 22:22:58 +0000766 const auto &M = *MF.getFunction().getParent();
Alex Lorenzab980492015-07-20 20:51:18 +0000767 SMDiagnostic Error;
768 for (const auto &YamlConstant : YamlMF.Constants) {
Diana Picusd5a00b02017-08-02 11:09:30 +0000769 if (YamlConstant.IsTargetSpecific)
770 // FIXME: Support target-specific constant pools
771 return error(YamlConstant.Value.SourceRange.Start,
772 "Can't parse target-specific constant pool entries yet");
Alex Lorenzab980492015-07-20 20:51:18 +0000773 const Constant *Value = dyn_cast_or_null<Constant>(
774 parseConstantValue(YamlConstant.Value.Value, Error, M));
775 if (!Value)
776 return error(Error, YamlConstant.Value.SourceRange);
777 unsigned Alignment =
778 YamlConstant.Alignment
779 ? YamlConstant.Alignment
780 : M.getDataLayout().getPrefTypeAlignment(Value->getType());
Alex Lorenz60bf5992015-07-30 22:00:17 +0000781 unsigned Index = ConstantPool.getConstantPoolIndex(Value, Alignment);
782 if (!ConstantPoolSlots.insert(std::make_pair(YamlConstant.ID.Value, Index))
783 .second)
784 return error(YamlConstant.ID.SourceRange.Start,
785 Twine("redefinition of constant pool item '%const.") +
786 Twine(YamlConstant.ID.Value) + "'");
Alex Lorenzab980492015-07-20 20:51:18 +0000787 }
788 return false;
789}
790
Matthias Braun83947862016-07-13 22:23:23 +0000791bool MIRParserImpl::initializeJumpTableInfo(PerFunctionMIParsingState &PFS,
792 const yaml::MachineJumpTable &YamlJTI) {
793 MachineJumpTableInfo *JTI = PFS.MF.getOrCreateJumpTableInfo(YamlJTI.Kind);
Alex Lorenz6799e9b2015-07-15 23:31:07 +0000794 for (const auto &Entry : YamlJTI.Entries) {
795 std::vector<MachineBasicBlock *> Blocks;
796 for (const auto &MBBSource : Entry.Blocks) {
797 MachineBasicBlock *MBB = nullptr;
Matthias Braun83947862016-07-13 22:23:23 +0000798 if (parseMBBReference(PFS, MBB, MBBSource.Value))
Alex Lorenz05fa73b2015-07-29 20:57:11 +0000799 return true;
Alex Lorenz6799e9b2015-07-15 23:31:07 +0000800 Blocks.push_back(MBB);
801 }
Alex Lorenz31d70682015-07-15 23:38:35 +0000802 unsigned Index = JTI->createJumpTableIndex(Blocks);
Alex Lorenz59ed5912015-07-31 23:13:23 +0000803 if (!PFS.JumpTableSlots.insert(std::make_pair(Entry.ID.Value, Index))
804 .second)
805 return error(Entry.ID.SourceRange.Start,
806 Twine("redefinition of jump table entry '%jump-table.") +
807 Twine(Entry.ID.Value) + "'");
Alex Lorenz6799e9b2015-07-15 23:31:07 +0000808 }
809 return false;
810}
811
Matthias Braun74ad41c2016-10-11 03:13:01 +0000812bool MIRParserImpl::parseMBBReference(PerFunctionMIParsingState &PFS,
Matthias Braun83947862016-07-13 22:23:23 +0000813 MachineBasicBlock *&MBB,
814 const yaml::StringValue &Source) {
Alex Lorenz05fa73b2015-07-29 20:57:11 +0000815 SMDiagnostic Error;
Matthias Braune35861d2016-07-13 23:27:50 +0000816 if (llvm::parseMBBReference(PFS, MBB, Source.Value, Error))
Alex Lorenz05fa73b2015-07-29 20:57:11 +0000817 return error(Error, Source.SourceRange);
818 return false;
819}
820
Alex Lorenz51af1602015-06-23 22:39:23 +0000821SMDiagnostic MIRParserImpl::diagFromMIStringDiag(const SMDiagnostic &Error,
822 SMRange SourceRange) {
823 assert(SourceRange.isValid() && "Invalid source range");
824 SMLoc Loc = SourceRange.Start;
825 bool HasQuote = Loc.getPointer() < SourceRange.End.getPointer() &&
826 *Loc.getPointer() == '\'';
827 // Translate the location of the error from the location in the MI string to
828 // the corresponding location in the MIR file.
829 Loc = Loc.getFromPointer(Loc.getPointer() + Error.getColumnNo() +
830 (HasQuote ? 1 : 0));
831
832 // TODO: Translate any source ranges as well.
833 return SM.GetMessage(Loc, Error.getKind(), Error.getMessage(), None,
834 Error.getFixIts());
835}
836
Alex Lorenz9b62cf62015-08-13 20:30:11 +0000837SMDiagnostic MIRParserImpl::diagFromBlockStringDiag(const SMDiagnostic &Error,
838 SMRange SourceRange) {
Alex Lorenz09b832c2015-05-29 17:05:41 +0000839 assert(SourceRange.isValid());
840
841 // Translate the location of the error from the location in the llvm IR string
842 // to the corresponding location in the MIR file.
843 auto LineAndColumn = SM.getLineAndColumn(SourceRange.Start);
844 unsigned Line = LineAndColumn.first + Error.getLineNo() - 1;
845 unsigned Column = Error.getColumnNo();
846 StringRef LineStr = Error.getLineContents();
847 SMLoc Loc = Error.getLoc();
848
849 // Get the full line and adjust the column number by taking the indentation of
850 // LLVM IR into account.
851 for (line_iterator L(*SM.getMemoryBuffer(SM.getMainFileID()), false), E;
852 L != E; ++L) {
853 if (L.line_number() == Line) {
854 LineStr = *L;
855 Loc = SMLoc::getFromPointer(LineStr.data());
856 auto Indent = LineStr.find(Error.getLineContents());
857 if (Indent != StringRef::npos)
858 Column += Indent;
859 break;
860 }
861 }
862
863 return SMDiagnostic(SM, Loc, Filename, Line, Column, Error.getKind(),
864 Error.getMessage(), LineStr, Error.getRanges(),
865 Error.getFixIts());
866}
867
Alex Lorenz735c47e2015-06-15 20:30:22 +0000868MIRParser::MIRParser(std::unique_ptr<MIRParserImpl> Impl)
869 : Impl(std::move(Impl)) {}
870
871MIRParser::~MIRParser() {}
872
Matthias Braun7bda1952017-06-06 00:44:35 +0000873std::unique_ptr<Module> MIRParser::parseIRModule() {
874 return Impl->parseIRModule();
875}
Alex Lorenz735c47e2015-06-15 20:30:22 +0000876
Matthias Braun7bda1952017-06-06 00:44:35 +0000877bool MIRParser::parseMachineFunctions(Module &M, MachineModuleInfo &MMI) {
878 return Impl->parseMachineFunctions(M, MMI);
Alex Lorenz735c47e2015-06-15 20:30:22 +0000879}
880
881std::unique_ptr<MIRParser> llvm::createMIRParserFromFile(StringRef Filename,
882 SMDiagnostic &Error,
883 LLVMContext &Context) {
Matthias Braun7e23fc02017-06-06 20:06:57 +0000884 auto FileOrErr = MemoryBuffer::getFileOrSTDIN(Filename);
Alex Lorenz2bdb4e12015-05-27 18:02:19 +0000885 if (std::error_code EC = FileOrErr.getError()) {
886 Error = SMDiagnostic(Filename, SourceMgr::DK_Error,
887 "Could not open input file: " + EC.message());
Alex Lorenz735c47e2015-06-15 20:30:22 +0000888 return nullptr;
Alex Lorenz2bdb4e12015-05-27 18:02:19 +0000889 }
Alex Lorenz735c47e2015-06-15 20:30:22 +0000890 return createMIRParser(std::move(FileOrErr.get()), Context);
Alex Lorenz2bdb4e12015-05-27 18:02:19 +0000891}
892
Alex Lorenz735c47e2015-06-15 20:30:22 +0000893std::unique_ptr<MIRParser>
894llvm::createMIRParser(std::unique_ptr<MemoryBuffer> Contents,
895 LLVMContext &Context) {
Mehdi Amini05188a62016-09-17 05:41:02 +0000896 auto Filename = Contents->getBufferIdentifier();
Mehdi Amini8d904e92016-09-17 05:33:58 +0000897 if (Context.shouldDiscardValueNames()) {
898 Context.diagnose(DiagnosticInfoMIRParser(
899 DS_Error,
900 SMDiagnostic(
901 Filename, SourceMgr::DK_Error,
902 "Can't read MIR with a Context that discards named Values")));
903 return nullptr;
904 }
Alex Lorenz735c47e2015-06-15 20:30:22 +0000905 return llvm::make_unique<MIRParser>(
906 llvm::make_unique<MIRParserImpl>(std::move(Contents), Filename, Context));
Alex Lorenz2bdb4e12015-05-27 18:02:19 +0000907}