LLVM  4.0.0
Parser.cpp
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 //===----------------------------------------------------------------------===//
13 
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;
24 
26  SlotMapping *Slots) {
27  SourceMgr SM;
28  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(F);
29  SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
30 
31  return LLParser(F.getBuffer(), SM, Err, &M, Slots).Run();
32 }
33 
34 std::unique_ptr<Module> llvm::parseAssembly(MemoryBufferRef F,
35  SMDiagnostic &Err,
37  SlotMapping *Slots) {
38  std::unique_ptr<Module> M =
39  make_unique<Module>(F.getBufferIdentifier(), Context);
40 
41  if (parseAssemblyInto(F, *M, Err, Slots))
42  return nullptr;
43 
44  return M;
45 }
46 
47 std::unique_ptr<Module> llvm::parseAssemblyFile(StringRef Filename,
48  SMDiagnostic &Err,
50  SlotMapping *Slots) {
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  }
58 
59  return parseAssembly(FileOrErr.get()->getMemBufferRef(), Err, Context, Slots);
60 }
61 
62 std::unique_ptr<Module> llvm::parseAssemblyString(StringRef AsmString,
63  SMDiagnostic &Err,
65  SlotMapping *Slots) {
66  MemoryBufferRef F(AsmString, "<string>");
67  return parseAssembly(F, Err, Context, Slots);
68 }
69 
71  const Module &M, const SlotMapping *Slots) {
72  SourceMgr SM;
73  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
74  SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
75  Constant *C;
76  if (LLParser(Asm, SM, Err, const_cast<Module *>(&M))
77  .parseStandaloneConstantValue(C, Slots))
78  return nullptr;
79  return C;
80 }
81 
83  const SlotMapping *Slots) {
84  unsigned Read;
85  Type *Ty = parseTypeAtBeginning(Asm, Read, Err, M, Slots);
86  if (!Ty)
87  return nullptr;
88  if (Read != Asm.size()) {
89  SourceMgr SM;
90  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
91  SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
92  Err = SM.GetMessage(SMLoc::getFromPointer(Asm.begin() + Read),
93  SourceMgr::DK_Error, "expected end of string");
94  return nullptr;
95  }
96  return Ty;
97 }
99  SMDiagnostic &Err, const Module &M,
100  const SlotMapping *Slots) {
101  SourceMgr SM;
102  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
103  SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
104  Type *Ty;
105  if (LLParser(Asm, SM, Err, const_cast<Module *>(&M))
106  .parseTypeAtBeginning(Ty, Read, Slots))
107  return nullptr;
108  return Ty;
109 }
std::error_code getError() const
Definition: ErrorOr.h:169
Represents either an error or a value T.
Definition: ErrorOr.h:68
LLVMContext & Context
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:70
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
static std::unique_ptr< MemoryBuffer > getMemBuffer(StringRef InputData, StringRef BufferName="", bool RequiresNullTerminator=true)
Open the specified memory range as a MemoryBuffer.
#define F(x, y, z)
Definition: MD5.cpp:51
unsigned AddNewSourceBuffer(std::unique_ptr< MemoryBuffer > F, SMLoc IncludeLoc)
Add a new source buffer to this source manager.
Definition: SourceMgr.h:118
std::unique_ptr< Module > parseAssembly(MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context, SlotMapping *Slots=nullptr)
parseAssemblyFile and parseAssemblyString are wrappers around this function.
Definition: Parser.cpp:34
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:98
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:135
iterator begin() const
Definition: StringRef.h:103
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:48
This is an important base class in LLVM.
Definition: Constant.h:42
This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling...
Definition: SourceMgr.h:35
StringRef getBuffer() const
Definition: MemoryBuffer.h:169
Module.h This file contains the declarations for the Module class.
bool parseAssemblyInto(MemoryBufferRef F, Module &M, SMDiagnostic &Err, SlotMapping *Slots=nullptr)
This function is the low-level interface to the LLVM Assembly Parser.
Definition: Parser.cpp:25
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
This struct contains the mappings from the slot numbers to unnamed metadata nodes, global values and types.
Definition: SlotMapping.h:33
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 "-".
std::unique_ptr< Module > parseAssemblyFile(StringRef Filename, SMDiagnostic &Error, LLVMContext &Context, SlotMapping *Slots=nullptr)
This function is the main interface to the LLVM Assembly Parser.
Definition: Parser.cpp:47
StringRef getBufferIdentifier() const
Definition: MemoryBuffer.h:171
std::unique_ptr< Module > parseAssemblyString(StringRef AsmString, SMDiagnostic &Error, LLVMContext &Context, SlotMapping *Slots=nullptr)
The function is a secondary interface to the LLVM Assembly Parser.
Definition: Parser.cpp:62
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
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:136
Type * parseType(StringRef Asm, SMDiagnostic &Err, const Module &M, const SlotMapping *Slots=nullptr)
Parse a type in the given string.
Definition: Parser.cpp:82
Represents a location in source code.
Definition: SMLoc.h:24
reference get()
Definition: ErrorOr.h:166
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Definition: SourceMgr.h:228