1 //===- MIRParser.cpp - MIR serialization format parser implementation -----===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the class that parses the optional LLVM IR and machine
11 // functions that are stored in MIR files.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/CodeGen/MIRParser/MIRParser.h"
16 #include "MIParser.h"
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/ADT/StringMap.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/AsmParser/Parser.h"
22 #include "llvm/AsmParser/SlotMapping.h"
23 #include "llvm/CodeGen/MachineFunction.h"
24 #include "llvm/CodeGen/MachineRegisterInfo.h"
25 #include "llvm/CodeGen/MIRYamlMapping.h"
26 #include "llvm/IR/BasicBlock.h"
27 #include "llvm/IR/DiagnosticInfo.h"
28 #include "llvm/IR/Instructions.h"
29 #include "llvm/IR/LLVMContext.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/IR/ValueSymbolTable.h"
32 #include "llvm/Support/LineIterator.h"
33 #include "llvm/Support/SMLoc.h"
34 #include "llvm/Support/SourceMgr.h"
35 #include "llvm/Support/MemoryBuffer.h"
36 #include "llvm/Support/YAMLTraits.h"
37 #include <memory>
38 
39 using namespace llvm;
40 
41 namespace llvm {
42 
43 /// This class implements the parsing of LLVM IR that's embedded inside a MIR
44 /// file.
45 class MIRParserImpl {
46   SourceMgr SM;
47   StringRef Filename;
48   LLVMContext &Context;
49   StringMap<std::unique_ptr<yaml::MachineFunction>> Functions;
50   SlotMapping IRSlots;
51 
52 public:
53   MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents, StringRef Filename,
54                 LLVMContext &Context);
55 
56   void reportDiagnostic(const SMDiagnostic &Diag);
57 
58   /// Report an error with the given message at unknown location.
59   ///
60   /// Always returns true.
61   bool error(const Twine &Message);
62 
63   /// Report a given error with the location translated from the location in an
64   /// embedded string literal to a location in the MIR file.
65   ///
66   /// Always returns true.
67   bool error(const SMDiagnostic &Error, SMRange SourceRange);
68 
69   /// Try to parse the optional LLVM module and the machine functions in the MIR
70   /// file.
71   ///
72   /// Return null if an error occurred.
73   std::unique_ptr<Module> parse();
74 
75   /// Parse the machine function in the current YAML document.
76   ///
77   /// \param NoLLVMIR - set to true when the MIR file doesn't have LLVM IR.
78   /// A dummy IR function is created and inserted into the given module when
79   /// this parameter is true.
80   ///
81   /// Return true if an error occurred.
82   bool parseMachineFunction(yaml::Input &In, Module &M, bool NoLLVMIR);
83 
84   /// Initialize the machine function to the state that's described in the MIR
85   /// file.
86   ///
87   /// Return true if error occurred.
88   bool initializeMachineFunction(MachineFunction &MF);
89 
90   /// Initialize the machine basic block using it's YAML representation.
91   ///
92   /// Return true if an error occurred.
93   bool initializeMachineBasicBlock(
94       MachineFunction &MF, MachineBasicBlock &MBB,
95       const yaml::MachineBasicBlock &YamlMBB,
96       const DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
97 
98   bool initializeRegisterInfo(MachineRegisterInfo &RegInfo,
99                               const yaml::MachineFunction &YamlMF);
100 
101 private:
102   /// Return a MIR diagnostic converted from an MI string diagnostic.
103   SMDiagnostic diagFromMIStringDiag(const SMDiagnostic &Error,
104                                     SMRange SourceRange);
105 
106   /// Return a MIR diagnostic converted from an LLVM assembly diagnostic.
107   SMDiagnostic diagFromLLVMAssemblyDiag(const SMDiagnostic &Error,
108                                         SMRange SourceRange);
109 
110   /// Create an empty function with the given name.
111   void createDummyFunction(StringRef Name, Module &M);
112 };
113 
114 } // end namespace llvm
115 
116 MIRParserImpl::MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents,
117                              StringRef Filename, LLVMContext &Context)
118     : SM(), Filename(Filename), Context(Context) {
119   SM.AddNewSourceBuffer(std::move(Contents), SMLoc());
120 }
121 
122 bool MIRParserImpl::error(const Twine &Message) {
123   Context.diagnose(DiagnosticInfoMIRParser(
124       DS_Error, SMDiagnostic(Filename, SourceMgr::DK_Error, Message.str())));
125   return true;
126 }
127 
128 bool MIRParserImpl::error(const SMDiagnostic &Error, SMRange SourceRange) {
129   assert(Error.getKind() == SourceMgr::DK_Error && "Expected an error");
130   reportDiagnostic(diagFromMIStringDiag(Error, SourceRange));
131   return true;
132 }
133 
134 void MIRParserImpl::reportDiagnostic(const SMDiagnostic &Diag) {
135   DiagnosticSeverity Kind;
136   switch (Diag.getKind()) {
137   case SourceMgr::DK_Error:
138     Kind = DS_Error;
139     break;
140   case SourceMgr::DK_Warning:
141     Kind = DS_Warning;
142     break;
143   case SourceMgr::DK_Note:
144     Kind = DS_Note;
145     break;
146   }
147   Context.diagnose(DiagnosticInfoMIRParser(Kind, Diag));
148 }
149 
150 static void handleYAMLDiag(const SMDiagnostic &Diag, void *Context) {
151   reinterpret_cast<MIRParserImpl *>(Context)->reportDiagnostic(Diag);
152 }
153 
154 std::unique_ptr<Module> MIRParserImpl::parse() {
155   yaml::Input In(SM.getMemoryBuffer(SM.getMainFileID())->getBuffer(),
156                  /*Ctxt=*/nullptr, handleYAMLDiag, this);
157   In.setContext(&In);
158 
159   if (!In.setCurrentDocument()) {
160     if (In.error())
161       return nullptr;
162     // Create an empty module when the MIR file is empty.
163     return llvm::make_unique<Module>(Filename, Context);
164   }
165 
166   std::unique_ptr<Module> M;
167   bool NoLLVMIR = false;
168   // Parse the block scalar manually so that we can return unique pointer
169   // without having to go trough YAML traits.
170   if (const auto *BSN =
171           dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) {
172     SMDiagnostic Error;
173     M = parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error,
174                       Context, &IRSlots);
175     if (!M) {
176       reportDiagnostic(diagFromLLVMAssemblyDiag(Error, BSN->getSourceRange()));
177       return M;
178     }
179     In.nextDocument();
180     if (!In.setCurrentDocument())
181       return M;
182   } else {
183     // Create an new, empty module.
184     M = llvm::make_unique<Module>(Filename, Context);
185     NoLLVMIR = true;
186   }
187 
188   // Parse the machine functions.
189   do {
190     if (parseMachineFunction(In, *M, NoLLVMIR))
191       return nullptr;
192     In.nextDocument();
193   } while (In.setCurrentDocument());
194 
195   return M;
196 }
197 
198 bool MIRParserImpl::parseMachineFunction(yaml::Input &In, Module &M,
199                                          bool NoLLVMIR) {
200   auto MF = llvm::make_unique<yaml::MachineFunction>();
201   yaml::yamlize(In, *MF, false);
202   if (In.error())
203     return true;
204   auto FunctionName = MF->Name;
205   if (Functions.find(FunctionName) != Functions.end())
206     return error(Twine("redefinition of machine function '") + FunctionName +
207                  "'");
208   Functions.insert(std::make_pair(FunctionName, std::move(MF)));
209   if (NoLLVMIR)
210     createDummyFunction(FunctionName, M);
211   else if (!M.getFunction(FunctionName))
212     return error(Twine("function '") + FunctionName +
213                  "' isn't defined in the provided LLVM IR");
214   return false;
215 }
216 
217 void MIRParserImpl::createDummyFunction(StringRef Name, Module &M) {
218   auto &Context = M.getContext();
219   Function *F = cast<Function>(M.getOrInsertFunction(
220       Name, FunctionType::get(Type::getVoidTy(Context), false)));
221   BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
222   new UnreachableInst(Context, BB);
223 }
224 
225 bool MIRParserImpl::initializeMachineFunction(MachineFunction &MF) {
226   auto It = Functions.find(MF.getName());
227   if (It == Functions.end())
228     return error(Twine("no machine function information for function '") +
229                  MF.getName() + "' in the MIR file");
230   // TODO: Recreate the machine function.
231   const yaml::MachineFunction &YamlMF = *It->getValue();
232   if (YamlMF.Alignment)
233     MF.setAlignment(YamlMF.Alignment);
234   MF.setExposesReturnsTwice(YamlMF.ExposesReturnsTwice);
235   MF.setHasInlineAsm(YamlMF.HasInlineAsm);
236   if (initializeRegisterInfo(MF.getRegInfo(), YamlMF))
237     return true;
238 
239   const auto &F = *MF.getFunction();
240   DenseMap<unsigned, MachineBasicBlock *> MBBSlots;
241   for (const auto &YamlMBB : YamlMF.BasicBlocks) {
242     const BasicBlock *BB = nullptr;
243     if (!YamlMBB.Name.empty()) {
244       BB = dyn_cast_or_null<BasicBlock>(
245           F.getValueSymbolTable().lookup(YamlMBB.Name));
246       if (!BB)
247         return error(Twine("basic block '") + YamlMBB.Name +
248                      "' is not defined in the function '" + MF.getName() + "'");
249     }
250     auto *MBB = MF.CreateMachineBasicBlock(BB);
251     MF.insert(MF.end(), MBB);
252     bool WasInserted = MBBSlots.insert(std::make_pair(YamlMBB.ID, MBB)).second;
253     if (!WasInserted)
254       return error(Twine("redefinition of machine basic block with id #") +
255                    Twine(YamlMBB.ID));
256   }
257 
258   // Initialize the machine basic blocks after creating them all so that the
259   // machine instructions parser can resolve the MBB references.
260   unsigned I = 0;
261   for (const auto &YamlMBB : YamlMF.BasicBlocks) {
262     if (initializeMachineBasicBlock(MF, *MF.getBlockNumbered(I++), YamlMBB,
263                                     MBBSlots))
264       return true;
265   }
266   return false;
267 }
268 
269 bool MIRParserImpl::initializeMachineBasicBlock(
270     MachineFunction &MF, MachineBasicBlock &MBB,
271     const yaml::MachineBasicBlock &YamlMBB,
272     const DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
273   MBB.setAlignment(YamlMBB.Alignment);
274   if (YamlMBB.AddressTaken)
275     MBB.setHasAddressTaken();
276   MBB.setIsLandingPad(YamlMBB.IsLandingPad);
277   SMDiagnostic Error;
278   // Parse the successors.
279   for (const auto &MBBSource : YamlMBB.Successors) {
280     MachineBasicBlock *SuccMBB = nullptr;
281     if (parseMBBReference(SuccMBB, SM, MF, MBBSource.Value, MBBSlots, IRSlots,
282                           Error))
283       return error(Error, MBBSource.SourceRange);
284     // TODO: Report an error when adding the same successor more than once.
285     MBB.addSuccessor(SuccMBB);
286   }
287   // Parse the instructions.
288   for (const auto &MISource : YamlMBB.Instructions) {
289     MachineInstr *MI = nullptr;
290     if (parseMachineInstr(MI, SM, MF, MISource.Value, MBBSlots, IRSlots, Error))
291       return error(Error, MISource.SourceRange);
292     MBB.insert(MBB.end(), MI);
293   }
294   return false;
295 }
296 
297 bool MIRParserImpl::initializeRegisterInfo(
298     MachineRegisterInfo &RegInfo, const yaml::MachineFunction &YamlMF) {
299   assert(RegInfo.isSSA());
300   if (!YamlMF.IsSSA)
301     RegInfo.leaveSSA();
302   assert(RegInfo.tracksLiveness());
303   if (!YamlMF.TracksRegLiveness)
304     RegInfo.invalidateLiveness();
305   RegInfo.enableSubRegLiveness(YamlMF.TracksSubRegLiveness);
306   return false;
307 }
308 
309 SMDiagnostic MIRParserImpl::diagFromMIStringDiag(const SMDiagnostic &Error,
310                                                  SMRange SourceRange) {
311   assert(SourceRange.isValid() && "Invalid source range");
312   SMLoc Loc = SourceRange.Start;
313   bool HasQuote = Loc.getPointer() < SourceRange.End.getPointer() &&
314                   *Loc.getPointer() == '\'';
315   // Translate the location of the error from the location in the MI string to
316   // the corresponding location in the MIR file.
317   Loc = Loc.getFromPointer(Loc.getPointer() + Error.getColumnNo() +
318                            (HasQuote ? 1 : 0));
319 
320   // TODO: Translate any source ranges as well.
321   return SM.GetMessage(Loc, Error.getKind(), Error.getMessage(), None,
322                        Error.getFixIts());
323 }
324 
325 SMDiagnostic MIRParserImpl::diagFromLLVMAssemblyDiag(const SMDiagnostic &Error,
326                                                      SMRange SourceRange) {
327   assert(SourceRange.isValid());
328 
329   // Translate the location of the error from the location in the llvm IR string
330   // to the corresponding location in the MIR file.
331   auto LineAndColumn = SM.getLineAndColumn(SourceRange.Start);
332   unsigned Line = LineAndColumn.first + Error.getLineNo() - 1;
333   unsigned Column = Error.getColumnNo();
334   StringRef LineStr = Error.getLineContents();
335   SMLoc Loc = Error.getLoc();
336 
337   // Get the full line and adjust the column number by taking the indentation of
338   // LLVM IR into account.
339   for (line_iterator L(*SM.getMemoryBuffer(SM.getMainFileID()), false), E;
340        L != E; ++L) {
341     if (L.line_number() == Line) {
342       LineStr = *L;
343       Loc = SMLoc::getFromPointer(LineStr.data());
344       auto Indent = LineStr.find(Error.getLineContents());
345       if (Indent != StringRef::npos)
346         Column += Indent;
347       break;
348     }
349   }
350 
351   return SMDiagnostic(SM, Loc, Filename, Line, Column, Error.getKind(),
352                       Error.getMessage(), LineStr, Error.getRanges(),
353                       Error.getFixIts());
354 }
355 
356 MIRParser::MIRParser(std::unique_ptr<MIRParserImpl> Impl)
357     : Impl(std::move(Impl)) {}
358 
359 MIRParser::~MIRParser() {}
360 
361 std::unique_ptr<Module> MIRParser::parseLLVMModule() { return Impl->parse(); }
362 
363 bool MIRParser::initializeMachineFunction(MachineFunction &MF) {
364   return Impl->initializeMachineFunction(MF);
365 }
366 
367 std::unique_ptr<MIRParser> llvm::createMIRParserFromFile(StringRef Filename,
368                                                          SMDiagnostic &Error,
369                                                          LLVMContext &Context) {
370   auto FileOrErr = MemoryBuffer::getFile(Filename);
371   if (std::error_code EC = FileOrErr.getError()) {
372     Error = SMDiagnostic(Filename, SourceMgr::DK_Error,
373                          "Could not open input file: " + EC.message());
374     return nullptr;
375   }
376   return createMIRParser(std::move(FileOrErr.get()), Context);
377 }
378 
379 std::unique_ptr<MIRParser>
380 llvm::createMIRParser(std::unique_ptr<MemoryBuffer> Contents,
381                       LLVMContext &Context) {
382   auto Filename = Contents->getBufferIdentifier();
383   return llvm::make_unique<MIRParser>(
384       llvm::make_unique<MIRParserImpl>(std::move(Contents), Filename, Context));
385 }
386