IRReader.cpp Source File (original) (raw)

20#include

21#include <system_error>

23using namespace llvm;

25namespace llvm {

27}

34std::unique_ptr

36 LLVMContext &Context, bool ShouldLazyLoadMetadata) {

37 if (isBitcode((const unsigned char *)Buffer->getBufferStart(),

38 (const unsigned char *)Buffer->getBufferEnd())) {

40 std::move(Buffer), Context, ShouldLazyLoadMetadata);

45 });

46 return nullptr;

47 }

48 return std::move(ModuleOrErr.get());

49 }

51 return parseAssembly(Buffer->getMemBufferRef(), Err, Context);

52}

57 bool ShouldLazyLoadMetadata) {

60 if (std::error_code EC = FileOrErr.getError()) {

62 "Could not open input file: " + EC.message());

63 return nullptr;

64 }

67 ShouldLazyLoadMetadata);

68}

78 (const unsigned char *)Buffer.getBufferEnd())) {

85 });

86 return nullptr;

87 }

88 return std::move(ModuleOrErr.get());

89 }

91 return parseAssembly(Buffer, Err, Context, nullptr,

94 ParserContext);

95}

103 if (std::error_code EC = FileOrErr.getError()) {

105 "Could not open input file: " + EC.message());

106 return nullptr;

107 }

108

109 return parseIR(FileOrErr.get()->getMemBufferRef(), Err, Context, Callbacks,

110 ParserContext);

111}

112

113

114

115

116

119 char **OutMessage) {

121

122 std::unique_ptr MB(unwrap(MemBuf));

123 *OutM =

125

126 if(!*OutM) {

127 if (OutMessage) {

128 std::string buf;

130

131 Diag.print(nullptr, os, false);

132

133 *OutMessage = strdup(buf.c_str());

134 }

135 return 1;

136 }

137

138 return 0;

139}

const char TimeIRParsingDescription[]

Definition IRReader.cpp:32

const char TimeIRParsingGroupDescription[]

Definition IRReader.cpp:30

const char TimeIRParsingName[]

Definition IRReader.cpp:31

const char TimeIRParsingGroupName[]

Definition IRReader.cpp:29

Module.h This file contains the declarations for the Module class.

Registry of file location information for LLVM IR constructs.

Base class for error info classes.

virtual std::string message() const

Return the error message as a string.

Represents either an error or a value T.

std::error_code getError() const

Lightweight error class with error context and mandatory checking.

Tagged union holding either a T or a Error.

Error takeError()

Take ownership of the stored error.

reference get()

Returns a reference to the stored T value.

This is an important class for using LLVM in a threaded context.

StringRef getBufferIdentifier() const

const char * getBufferStart() const

const char * getBufferEnd() const

static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileOrSTDIN(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, std::optional< Align > Alignment=std::nullopt)

Open the specified file as a MemoryBuffer, or open stdin if the Filename is "-".

Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...

LLVM_ABI void print(const char *ProgName, raw_ostream &S, bool ShowColors=true, bool ShowKindLabel=true, bool ShowLocation=true) const

StringRef - Represent a constant reference to a string, i.e.

A raw_ostream that writes to an std::string.

LLVMBool LLVMParseIRInContext(LLVMContextRef ContextRef, LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM, char **OutMessage)

Read LLVM IR from a memory buffer and convert it into an in-memory Module object.

Definition IRReader.cpp:117

struct LLVMOpaqueMemoryBuffer * LLVMMemoryBufferRef

LLVM uses a polymorphic type hierarchy which C cannot represent, therefore parameters must be passed ...

struct LLVMOpaqueContext * LLVMContextRef

The top-level container for all LLVM global data.

struct LLVMOpaqueModule * LLVMModuleRef

The top-level container for all other LLVM Intermediate Representation (IR) objects.

This is an optimization pass for GlobalISel generic memory operations.

LLVM_ABI Expected< std::unique_ptr< Module > > parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context, ParserCallbacks Callbacks={})

Read the specified bitcode file, returning the module.

void handleAllErrors(Error E, HandlerTs &&... Handlers)

Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...

LLVM_ABI std::unique_ptr< Module > parseAssembly(MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context, SlotMapping *Slots=nullptr, DataLayoutCallbackTy DataLayoutCallback=[](StringRef, StringRef) { return std::nullopt;}, AsmParserContext *ParserContext=nullptr)

parseAssemblyFile and parseAssemblyString are wrappers around this function.

LLVM_ABI bool TimePassesIsEnabled

If the user specifies the -time-passes argument on an LLVM tool command line then the value of this b...

Definition IRReader.cpp:26

LLVM_ABI std::unique_ptr< Module > parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err, LLVMContext &Context, ParserCallbacks Callbacks={}, AsmParserContext *ParserContext=nullptr)

If the given MemoryBuffer holds a bitcode image, return a Module for it.

Definition IRReader.cpp:70

Attribute unwrap(LLVMAttributeRef Attr)

LLVM_ABI std::unique_ptr< Module > getLazyIRFileModule(StringRef Filename, SMDiagnostic &Err, LLVMContext &Context, bool ShouldLazyLoadMetadata=false)

If the given file holds a bitcode image, return a Module for it which does lazy deserialization of fu...

Definition IRReader.cpp:54

LLVMAttributeRef wrap(Attribute Attr)

LLVM_ABI std::unique_ptr< Module > parseIRFile(StringRef Filename, SMDiagnostic &Err, LLVMContext &Context, ParserCallbacks Callbacks={}, AsmParserContext *ParserContext=nullptr)

If the given file holds a bitcode image, return a Module for it.

Definition IRReader.cpp:97

bool isBitcode(const unsigned char *BufPtr, const unsigned char *BufEnd)

isBitcode - Return true if the given bytes are the magic bytes for LLVM IR bitcode,...

LLVM_ABI Expected< std::unique_ptr< Module > > getOwningLazyBitcodeModule(std::unique_ptr< MemoryBuffer > &&Buffer, LLVMContext &Context, bool ShouldLazyLoadMetadata=false, bool IsImporting=false, ParserCallbacks Callbacks={})

Like getLazyBitcodeModule, except that the module takes ownership of the memory buffer if successful.

LLVM_ABI std::unique_ptr< Module > getLazyIRModule(std::unique_ptr< MemoryBuffer > Buffer, SMDiagnostic &Err, LLVMContext &Context, bool ShouldLazyLoadMetadata=false)

If the given MemoryBuffer holds a bitcode image, return a Module for it which does lazy deserializati...

Definition IRReader.cpp:35

This class is basically a combination of TimeRegion and Timer.

std::optional< DataLayoutCallbackFuncTy > DataLayout