Deleted Added
sdiff udiff text old ( 276479 ) new ( 280031 )
full compact
IRReader.cpp (276479) IRReader.cpp (280031)
1//===---- IRReader.cpp - Reader for LLVM IR files -------------------------===//
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//===----------------------------------------------------------------------===//

--- 15 unchanged lines hidden (view full) ---

24
25namespace llvm {
26 extern bool TimePassesIsEnabled;
27}
28
29static const char *const TimeIRParsingGroupName = "LLVM IR Parsing";
30static const char *const TimeIRParsingName = "Parse IR";
31
1//===---- IRReader.cpp - Reader for LLVM IR files -------------------------===//
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//===----------------------------------------------------------------------===//

--- 15 unchanged lines hidden (view full) ---

24
25namespace llvm {
26 extern bool TimePassesIsEnabled;
27}
28
29static const char *const TimeIRParsingGroupName = "LLVM IR Parsing";
30static const char *const TimeIRParsingName = "Parse IR";
31
32static Module *getLazyIRModule(MemoryBuffer *Buffer, SMDiagnostic &Err,
33 LLVMContext &Context) {
32static std::unique_ptr<Module>
33getLazyIRModule(std::unique_ptr<MemoryBuffer> Buffer, SMDiagnostic &Err,
34 LLVMContext &Context) {
34 if (isBitcode((const unsigned char *)Buffer->getBufferStart(),
35 (const unsigned char *)Buffer->getBufferEnd())) {
35 if (isBitcode((const unsigned char *)Buffer->getBufferStart(),
36 (const unsigned char *)Buffer->getBufferEnd())) {
36 std::string ErrMsg;
37 ErrorOr<Module *> ModuleOrErr = getLazyBitcodeModule(Buffer, Context);
37 ErrorOr<Module *> ModuleOrErr =
38 getLazyBitcodeModule(std::move(Buffer), Context);
38 if (std::error_code EC = ModuleOrErr.getError()) {
39 Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error,
40 EC.message());
39 if (std::error_code EC = ModuleOrErr.getError()) {
40 Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error,
41 EC.message());
41 // getLazyBitcodeModule does not take ownership of the Buffer in the
42 // case of an error.
43 delete Buffer;
44 return nullptr;
45 }
42 return nullptr;
43 }
46 return ModuleOrErr.get();
44 return std::unique_ptr<Module>(ModuleOrErr.get());
47 }
48
45 }
46
49 return ParseAssembly(Buffer, nullptr, Err, Context);
47 return parseAssembly(Buffer->getMemBufferRef(), Err, Context);
50}
51
48}
49
52Module *llvm::getLazyIRFileModule(const std::string &Filename, SMDiagnostic &Err,
53 LLVMContext &Context) {
50std::unique_ptr<Module> llvm::getLazyIRFileModule(StringRef Filename,
51 SMDiagnostic &Err,
52 LLVMContext &Context) {
54 ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
55 MemoryBuffer::getFileOrSTDIN(Filename);
56 if (std::error_code EC = FileOrErr.getError()) {
57 Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
58 "Could not open input file: " + EC.message());
59 return nullptr;
60 }
61
53 ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
54 MemoryBuffer::getFileOrSTDIN(Filename);
55 if (std::error_code EC = FileOrErr.getError()) {
56 Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
57 "Could not open input file: " + EC.message());
58 return nullptr;
59 }
60
62 return getLazyIRModule(FileOrErr.get().release(), Err, Context);
61 return getLazyIRModule(std::move(FileOrErr.get()), Err, Context);
63}
64
62}
63
65Module *llvm::ParseIR(MemoryBuffer *Buffer, SMDiagnostic &Err,
66 LLVMContext &Context) {
64std::unique_ptr<Module> llvm::parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err,
65 LLVMContext &Context) {
67 NamedRegionTimer T(TimeIRParsingName, TimeIRParsingGroupName,
68 TimePassesIsEnabled);
66 NamedRegionTimer T(TimeIRParsingName, TimeIRParsingGroupName,
67 TimePassesIsEnabled);
69 if (isBitcode((const unsigned char *)Buffer->getBufferStart(),
70 (const unsigned char *)Buffer->getBufferEnd())) {
68 if (isBitcode((const unsigned char *)Buffer.getBufferStart(),
69 (const unsigned char *)Buffer.getBufferEnd())) {
71 ErrorOr<Module *> ModuleOrErr = parseBitcodeFile(Buffer, Context);
70 ErrorOr<Module *> ModuleOrErr = parseBitcodeFile(Buffer, Context);
72 Module *M = nullptr;
73 if (std::error_code EC = ModuleOrErr.getError())
74 Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error,
71 if (std::error_code EC = ModuleOrErr.getError()) {
72 Err = SMDiagnostic(Buffer.getBufferIdentifier(), SourceMgr::DK_Error,
75 EC.message());
73 EC.message());
76 else
77 M = ModuleOrErr.get();
78 // parseBitcodeFile does not take ownership of the Buffer.
79 return M;
74 return nullptr;
75 }
76 return std::unique_ptr<Module>(ModuleOrErr.get());
80 }
81
77 }
78
82 return ParseAssembly(MemoryBuffer::getMemBuffer(
83 Buffer->getBuffer(), Buffer->getBufferIdentifier()),
84 nullptr, Err, Context);
79 return parseAssembly(Buffer, Err, Context);
85}
86
80}
81
87Module *llvm::ParseIRFile(const std::string &Filename, SMDiagnostic &Err,
88 LLVMContext &Context) {
82std::unique_ptr<Module> llvm::parseIRFile(StringRef Filename, SMDiagnostic &Err,
83 LLVMContext &Context) {
89 ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
90 MemoryBuffer::getFileOrSTDIN(Filename);
91 if (std::error_code EC = FileOrErr.getError()) {
92 Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
93 "Could not open input file: " + EC.message());
94 return nullptr;
95 }
96
84 ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
85 MemoryBuffer::getFileOrSTDIN(Filename);
86 if (std::error_code EC = FileOrErr.getError()) {
87 Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
88 "Could not open input file: " + EC.message());
89 return nullptr;
90 }
91
97 return ParseIR(FileOrErr.get().get(), Err, Context);
92 return parseIR(FileOrErr.get()->getMemBufferRef(), Err, Context);
98}
99
100//===----------------------------------------------------------------------===//
101// C API.
102//===----------------------------------------------------------------------===//
103
104LLVMBool LLVMParseIRInContext(LLVMContextRef ContextRef,
105 LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM,
106 char **OutMessage) {
107 SMDiagnostic Diag;
108
109 std::unique_ptr<MemoryBuffer> MB(unwrap(MemBuf));
93}
94
95//===----------------------------------------------------------------------===//
96// C API.
97//===----------------------------------------------------------------------===//
98
99LLVMBool LLVMParseIRInContext(LLVMContextRef ContextRef,
100 LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM,
101 char **OutMessage) {
102 SMDiagnostic Diag;
103
104 std::unique_ptr<MemoryBuffer> MB(unwrap(MemBuf));
110 *OutM = wrap(ParseIR(MB.get(), Diag, *unwrap(ContextRef)));
105 *OutM =
106 wrap(parseIR(MB->getMemBufferRef(), Diag, *unwrap(ContextRef)).release());
111
112 if(!*OutM) {
113 if (OutMessage) {
114 std::string buf;
115 raw_string_ostream os(buf);
116
117 Diag.print(nullptr, os, false);
118 os.flush();
119
120 *OutMessage = strdup(buf.c_str());
121 }
122 return 1;
123 }
124
125 return 0;
126}
107
108 if(!*OutM) {
109 if (OutMessage) {
110 std::string buf;
111 raw_string_ostream os(buf);
112
113 Diag.print(nullptr, os, false);
114 os.flush();
115
116 *OutMessage = strdup(buf.c_str());
117 }
118 return 1;
119 }
120
121 return 0;
122}