/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/lib/IRReader/IRReader.cpp
Line | Count | Source (jump to first uncovered line) |
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 | | //===----------------------------------------------------------------------===// |
9 | | |
10 | | #include "llvm/IRReader/IRReader.h" |
11 | | #include "llvm-c/Core.h" |
12 | | #include "llvm-c/IRReader.h" |
13 | | #include "llvm/AsmParser/Parser.h" |
14 | | #include "llvm/Bitcode/BitcodeReader.h" |
15 | | #include "llvm/IR/LLVMContext.h" |
16 | | #include "llvm/IR/Module.h" |
17 | | #include "llvm/Support/MemoryBuffer.h" |
18 | | #include "llvm/Support/SourceMgr.h" |
19 | | #include "llvm/Support/Timer.h" |
20 | | #include "llvm/Support/raw_ostream.h" |
21 | | #include <system_error> |
22 | | |
23 | | using namespace llvm; |
24 | | |
25 | | namespace llvm { |
26 | | extern bool TimePassesIsEnabled; |
27 | | } |
28 | | |
29 | | static const char *const TimeIRParsingGroupName = "irparse"; |
30 | | static const char *const TimeIRParsingGroupDescription = "LLVM IR Parsing"; |
31 | | static const char *const TimeIRParsingName = "parse"; |
32 | | static const char *const TimeIRParsingDescription = "Parse IR"; |
33 | | |
34 | | static std::unique_ptr<Module> |
35 | | getLazyIRModule(std::unique_ptr<MemoryBuffer> Buffer, SMDiagnostic &Err, |
36 | 532 | LLVMContext &Context, bool ShouldLazyLoadMetadata) { |
37 | 532 | if (isBitcode((const unsigned char *)Buffer->getBufferStart(), |
38 | 532 | (const unsigned char *)Buffer->getBufferEnd())) { |
39 | 179 | Expected<std::unique_ptr<Module>> ModuleOrErr = getOwningLazyBitcodeModule( |
40 | 179 | std::move(Buffer), Context, ShouldLazyLoadMetadata); |
41 | 179 | if (Error E179 = ModuleOrErr.takeError()) { |
42 | 0 | handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) { |
43 | 0 | Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error, |
44 | 0 | EIB.message()); |
45 | 0 | }); |
46 | 0 | return nullptr; |
47 | 0 | } |
48 | 179 | return std::move(ModuleOrErr.get()); |
49 | 179 | } |
50 | 353 | |
51 | 353 | return parseAssembly(Buffer->getMemBufferRef(), Err, Context); |
52 | 353 | } |
53 | | |
54 | | std::unique_ptr<Module> llvm::getLazyIRFileModule(StringRef Filename, |
55 | | SMDiagnostic &Err, |
56 | | LLVMContext &Context, |
57 | 532 | bool ShouldLazyLoadMetadata) { |
58 | 532 | ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr = |
59 | 532 | MemoryBuffer::getFileOrSTDIN(Filename); |
60 | 532 | if (std::error_code EC532 = FileOrErr.getError()) { |
61 | 0 | Err = SMDiagnostic(Filename, SourceMgr::DK_Error, |
62 | 0 | "Could not open input file: " + EC.message()); |
63 | 0 | return nullptr; |
64 | 0 | } |
65 | 532 | |
66 | 532 | return getLazyIRModule(std::move(FileOrErr.get()), Err, Context, |
67 | 532 | ShouldLazyLoadMetadata); |
68 | 532 | } |
69 | | |
70 | | std::unique_ptr<Module> llvm::parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err, |
71 | 32.7k | LLVMContext &Context) { |
72 | 32.7k | NamedRegionTimer T(TimeIRParsingName, TimeIRParsingDescription, |
73 | 32.7k | TimeIRParsingGroupName, TimeIRParsingGroupDescription, |
74 | 32.7k | TimePassesIsEnabled); |
75 | 32.7k | if (isBitcode((const unsigned char *)Buffer.getBufferStart(), |
76 | 32.7k | (const unsigned char *)Buffer.getBufferEnd())) { |
77 | 8.61k | Expected<std::unique_ptr<Module>> ModuleOrErr = |
78 | 8.61k | parseBitcodeFile(Buffer, Context); |
79 | 8.61k | if (Error E8.61k = ModuleOrErr.takeError()) { |
80 | 0 | handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) { |
81 | 0 | Err = SMDiagnostic(Buffer.getBufferIdentifier(), SourceMgr::DK_Error, |
82 | 0 | EIB.message()); |
83 | 0 | }); |
84 | 0 | return nullptr; |
85 | 0 | } |
86 | 8.61k | return std::move(ModuleOrErr.get()); |
87 | 8.61k | } |
88 | 24.1k | |
89 | 24.1k | return parseAssembly(Buffer, Err, Context); |
90 | 24.1k | } |
91 | | |
92 | | std::unique_ptr<Module> llvm::parseIRFile(StringRef Filename, SMDiagnostic &Err, |
93 | 24.4k | LLVMContext &Context) { |
94 | 24.4k | ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr = |
95 | 24.4k | MemoryBuffer::getFileOrSTDIN(Filename); |
96 | 24.4k | if (std::error_code EC24.4k = FileOrErr.getError()) { |
97 | 2 | Err = SMDiagnostic(Filename, SourceMgr::DK_Error, |
98 | 2 | "Could not open input file: " + EC.message()); |
99 | 2 | return nullptr; |
100 | 2 | } |
101 | 24.4k | |
102 | 24.4k | return parseIR(FileOrErr.get()->getMemBufferRef(), Err, Context); |
103 | 24.4k | } |
104 | | |
105 | | //===----------------------------------------------------------------------===// |
106 | | // C API. |
107 | | //===----------------------------------------------------------------------===// |
108 | | |
109 | | LLVMBool LLVMParseIRInContext(LLVMContextRef ContextRef, |
110 | | LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM, |
111 | 0 | char **OutMessage) { |
112 | 0 | SMDiagnostic Diag; |
113 | 0 |
|
114 | 0 | std::unique_ptr<MemoryBuffer> MB(unwrap(MemBuf)); |
115 | 0 | *OutM = |
116 | 0 | wrap(parseIR(MB->getMemBufferRef(), Diag, *unwrap(ContextRef)).release()); |
117 | 0 |
|
118 | 0 | if(!*OutM0 ) { |
119 | 0 | if (OutMessage0 ) { |
120 | 0 | std::string buf; |
121 | 0 | raw_string_ostream os(buf); |
122 | 0 |
|
123 | 0 | Diag.print(nullptr, os, false); |
124 | 0 | os.flush(); |
125 | 0 |
|
126 | 0 | *OutMessage = strdup(buf.c_str()); |
127 | 0 | } |
128 | 0 | return 1; |
129 | 0 | } |
130 | 0 |
|
131 | 0 | return 0; |
132 | 0 | } |