LLVM  6.0.0svn
Go to the documentation of this file.
1 //===- Parser.cpp - Main dispatch module for the Parser library -----------===//
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 library implements the functionality defined in llvm/AsmParser/Parser.h
11 //
12 //===----------------------------------------------------------------------===//
14 #include "llvm/AsmParser/Parser.h"
15 #include "LLParser.h"
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/IR/Module.h"
19 #include "llvm/Support/SourceMgr.h"
21 #include <cstring>
22 #include <system_error>
23 using namespace llvm;
26  SlotMapping *Slots, bool UpgradeDebugInfo) {
27  SourceMgr SM;
28  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(F);
29  SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
31  return LLParser(F.getBuffer(), SM, Err, &M, Slots, UpgradeDebugInfo).Run();
32 }
34 std::unique_ptr<Module>
36  SlotMapping *Slots, bool UpgradeDebugInfo) {
37  std::unique_ptr<Module> M =
38  make_unique<Module>(F.getBufferIdentifier(), Context);
40  if (parseAssemblyInto(F, *M, Err, Slots, UpgradeDebugInfo))
41  return nullptr;
43  return M;
44 }
46 std::unique_ptr<Module> llvm::parseAssemblyFile(StringRef Filename,
47  SMDiagnostic &Err,
49  SlotMapping *Slots,
50  bool UpgradeDebugInfo) {
53  if (std::error_code EC = FileOrErr.getError()) {
54  Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
55  "Could not open input file: " + EC.message());
56  return nullptr;
57  }
59  return parseAssembly(FileOrErr.get()->getMemBufferRef(), Err, Context, Slots,
61 }
63 std::unique_ptr<Module> llvm::parseAssemblyString(StringRef AsmString,
64  SMDiagnostic &Err,
66  SlotMapping *Slots,
67  bool UpgradeDebugInfo) {
68  MemoryBufferRef F(AsmString, "<string>");
69  return parseAssembly(F, Err, Context, Slots, UpgradeDebugInfo);
70 }
73  const Module &M, const SlotMapping *Slots) {
74  SourceMgr SM;
75  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
76  SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
77  Constant *C;
78  if (LLParser(Asm, SM, Err, const_cast<Module *>(&M))
79  .parseStandaloneConstantValue(C, Slots))
80  return nullptr;
81  return C;
82 }
85  const SlotMapping *Slots) {
86  unsigned Read;
87  Type *Ty = parseTypeAtBeginning(Asm, Read, Err, M, Slots);
88  if (!Ty)
89  return nullptr;
90  if (Read != Asm.size()) {
91  SourceMgr SM;
92  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
93  SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
94  Err = SM.GetMessage(SMLoc::getFromPointer(Asm.begin() + Read),
95  SourceMgr::DK_Error, "expected end of string");
96  return nullptr;
97  }
98  return Ty;
99 }
101  SMDiagnostic &Err, const Module &M,
102  const SlotMapping *Slots) {
103  SourceMgr SM;
104  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
105  SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
106  Type *Ty;
107  if (LLParser(Asm, SM, Err, const_cast<Module *>(&M))
108  .parseTypeAtBeginning(Ty, Read, Slots))
109  return nullptr;
110  return Ty;
111 }
uint64_t CallInst * C
std::unique_ptr< Module > parseAssembly(MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context, SlotMapping *Slots=nullptr, bool UpgradeDebugInfo=true)
parseAssemblyFile and parseAssemblyString are wrappers around this function.
Definition: Parser.cpp:35
Represents either an error or a value T.
Definition: ErrorOr.h:69
bool parseAssemblyInto(MemoryBufferRef F, Module &M, SMDiagnostic &Err, SlotMapping *Slots=nullptr, bool UpgradeDebugInfo=true)
This function is the low-level interface to the LLVM Assembly Parser.
Definition: Parser.cpp:25
LLVMContext & Context
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
Constant * parseConstantValue(StringRef Asm, SMDiagnostic &Err, const Module &M, const SlotMapping *Slots=nullptr)
Parse a type and a constant value in the given string.
Definition: Parser.cpp:72
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
size - Get the string size.
Definition: StringRef.h:138
static std::unique_ptr< MemoryBuffer > getMemBuffer(StringRef InputData, StringRef BufferName="", bool RequiresNullTerminator=true)
Open the specified memory range as a MemoryBuffer.
StringRef getBuffer() const
Definition: MemoryBuffer.h:170
std::unique_ptr< Module > parseAssemblyFile(StringRef Filename, SMDiagnostic &Error, LLVMContext &Context, SlotMapping *Slots=nullptr, bool UpgradeDebugInfo=true)
This function is the main interface to the LLVM Assembly Parser.
Definition: Parser.cpp:46
unsigned AddNewSourceBuffer(std::unique_ptr< MemoryBuffer > F, SMLoc IncludeLoc)
Add a new source buffer to this source manager.
Definition: SourceMgr.h:125
Type * parseTypeAtBeginning(StringRef Asm, unsigned &Read, SMDiagnostic &Err, const Module &M, const SlotMapping *Slots=nullptr)
Parse a string Asm that starts with a type.
Definition: Parser.cpp:100
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
std::unique_ptr< Module > parseAssemblyString(StringRef AsmString, SMDiagnostic &Error, LLVMContext &Context, SlotMapping *Slots=nullptr, bool UpgradeDebugInfo=true)
The function is a secondary interface to the LLVM Assembly Parser.
Definition: Parser.cpp:63
This is an important base class in LLVM.
Definition: Constant.h:42
std::error_code getError() const
Definition: ErrorOr.h:172
bool UpgradeDebugInfo(Module &M)
Check the debug info version number, if it is out-dated, drop the debug info.
This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling...
Definition: SourceMgr.h:41
SMDiagnostic GetMessage(SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges=None, ArrayRef< SMFixIt > FixIts=None) const
Return an SMDiagnostic at the specified location with the specified string.
Definition: SourceMgr.cpp:146
Module.h This file contains the declarations for the Module class.
StringRef getBufferIdentifier() const
Definition: MemoryBuffer.h:172
This struct contains the mappings from the slot numbers to unnamed metadata nodes, global values and types.
Definition: SlotMapping.h:33
iterator begin() const
Definition: StringRef.h:106
static SMLoc getFromPointer(const char *Ptr)
Definition: SMLoc.h:37
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileOrSTDIN(const Twine &Filename, int64_t FileSize=-1, bool RequiresNullTerminator=true)
Open the specified file as a MemoryBuffer, or open stdin if the Filename is "-".
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Type * parseType(StringRef Asm, SMDiagnostic &Err, const Module &M, const SlotMapping *Slots=nullptr)
Parse a type in the given string.
Definition: Parser.cpp:84
Represents a location in source code.
Definition: SMLoc.h:24
reference get()
Definition: ErrorOr.h:169
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Definition: SourceMgr.h:233