1//===---- IRReader.cpp - Reader for LLVM IR files -------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "llvm/IRReader/IRReader.h"
10#include "llvm-c/IRReader.h"
11#include "llvm/AsmParser/AsmParserContext.h"
12#include "llvm/AsmParser/Parser.h"
13#include "llvm/Bitcode/BitcodeReader.h"
14#include "llvm/IR/LLVMContext.h"
15#include "llvm/IR/Module.h"
16#include "llvm/IR/PassTimingInfo.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 <cstring>
22#include <optional>
23#include <system_error>
24
25using namespace llvm;
26
27const char TimeIRParsingGroupName[] = "irparse";
28const char TimeIRParsingGroupDescription[] = "LLVM IR Parsing";
29const char TimeIRParsingName[] = "parse";
30const char TimeIRParsingDescription[] = "Parse IR";
31
32std::unique_ptr<Module>
33llvm::getLazyIRModule(std::unique_ptr<MemoryBuffer> Buffer, SMDiagnostic &Err,
34 LLVMContext &Context, bool ShouldLazyLoadMetadata) {
35 if (isBitcode(BufPtr: (const unsigned char *)Buffer->getBufferStart(),
36 BufEnd: (const unsigned char *)Buffer->getBufferEnd())) {
37 Expected<std::unique_ptr<Module>> ModuleOrErr = getOwningLazyBitcodeModule(
38 Buffer: std::move(Buffer), Context, ShouldLazyLoadMetadata);
39 if (Error E = ModuleOrErr.takeError()) {
40 handleAllErrors(E: std::move(E), Handlers: [&](ErrorInfoBase &EIB) {
41 Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error,
42 EIB.message());
43 });
44 return nullptr;
45 }
46 return std::move(ModuleOrErr.get());
47 }
48
49 return parseAssembly(F: Buffer->getMemBufferRef(), Err, Context);
50}
51
52std::unique_ptr<Module> llvm::getLazyIRFileModule(StringRef Filename,
53 SMDiagnostic &Err,
54 LLVMContext &Context,
55 bool ShouldLazyLoadMetadata) {
56 ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
57 MemoryBuffer::getFileOrSTDIN(Filename);
58 if (std::error_code EC = FileOrErr.getError()) {
59 Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
60 "Could not open input file: " + EC.message());
61 return nullptr;
62 }
63
64 return getLazyIRModule(Buffer: std::move(FileOrErr.get()), Err, Context,
65 ShouldLazyLoadMetadata);
66}
67
68std::unique_ptr<Module> llvm::parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err,
69 LLVMContext &Context,
70 ParserCallbacks Callbacks,
71 llvm::AsmParserContext *ParserContext) {
72 NamedRegionTimer T(TimeIRParsingName, TimeIRParsingDescription,
73 TimeIRParsingGroupName, TimeIRParsingGroupDescription,
74 TimePassesIsEnabled);
75 if (isBitcode(BufPtr: (const unsigned char *)Buffer.getBufferStart(),
76 BufEnd: (const unsigned char *)Buffer.getBufferEnd())) {
77 Expected<std::unique_ptr<Module>> ModuleOrErr =
78 parseBitcodeFile(Buffer, Context, Callbacks);
79 if (Error E = ModuleOrErr.takeError()) {
80 handleAllErrors(E: std::move(E), Handlers: [&](ErrorInfoBase &EIB) {
81 Err = SMDiagnostic(Buffer.getBufferIdentifier(), SourceMgr::DK_Error,
82 EIB.message());
83 });
84 return nullptr;
85 }
86 return std::move(ModuleOrErr.get());
87 }
88
89 return parseAssembly(F: Buffer, Err, Context, Slots: nullptr,
90 DataLayoutCallback: Callbacks.DataLayout.value_or(
91 u: [](StringRef, StringRef) { return std::nullopt; }),
92 ParserContext);
93}
94
95std::unique_ptr<Module> llvm::parseIRFile(StringRef Filename, SMDiagnostic &Err,
96 LLVMContext &Context,
97 ParserCallbacks Callbacks,
98 AsmParserContext *ParserContext) {
99 ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
100 MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/true);
101 if (std::error_code EC = FileOrErr.getError()) {
102 Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
103 "Could not open input file: " + EC.message());
104 return nullptr;
105 }
106
107 return parseIR(Buffer: FileOrErr.get()->getMemBufferRef(), Err, Context, Callbacks,
108 ParserContext);
109}
110
111//===----------------------------------------------------------------------===//
112// C API.
113//===----------------------------------------------------------------------===//
114
115LLVMBool LLVMParseIRInContext(LLVMContextRef ContextRef,
116 LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM,
117 char **OutMessage) {
118 std::unique_ptr<MemoryBuffer> MB(unwrap(P: MemBuf));
119 return LLVMParseIRInContext2(ContextRef, MemBuf: wrap(P: MB.get()), OutM, OutMessage);
120}
121
122LLVMBool LLVMParseIRInContext2(LLVMContextRef ContextRef,
123 LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM,
124 char **OutMessage) {
125 SMDiagnostic Diag;
126
127 *OutM = wrap(P: parseIR(Buffer: *unwrap(P: MemBuf), Err&: Diag, Context&: *unwrap(P: ContextRef)).release());
128
129 if (*OutM)
130 return 0;
131
132 if (OutMessage) {
133 std::string Buf;
134 raw_string_ostream OS(Buf);
135 Diag.print(ProgName: nullptr, S&: OS, /*ShowColors=*/false);
136 *OutMessage = strdup(s: Buf.c_str());
137 }
138
139 return 1;
140}
141