llvm/lib/Bitcode/Reader/BitReader.cpp

   1 //===-- BitReader.cpp -----------------------------------------------------===//
   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-c/BitReader.h"
  10 #include "llvm-c/Core.h"
  11 #include "llvm/Bitcode/BitcodeReader.h"
  12 #include "llvm/IR/LLVMContext.h"
  13 #include "llvm/IR/Module.h"
  14 #include "llvm/Support/MemoryBuffer.h"
  15 #include <cstring>
  16 #include <string>
  17
  18 using namespace llvm;
  19
  20 /* Builds a module from the bitcode in the specified memory buffer, returning a
  21    reference to the module via the OutModule parameter. Returns 0 on success.
  22    Optionally returns a human-readable error message via OutMessage. */
  23 LLVMBool LLVMParseBitcode(LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutModule,
  24                           char **OutMessage) {
  25   return LLVMParseBitcodeInContext(LLVMGetGlobalContext(), MemBuf, OutModule,
  26                                    OutMessage);
  27 }
  28
  29 LLVMBool LLVMParseBitcode2(LLVMMemoryBufferRef MemBuf,
  30                            LLVMModuleRef *OutModule) {
  31   return LLVMParseBitcodeInContext2(LLVMGetGlobalContext(), MemBuf, OutModule);
  32 }
  33
  34 LLVMBool LLVMParseBitcodeInContext(LLVMContextRef ContextRef,
  35                                    LLVMMemoryBufferRef MemBuf,
  36                                    LLVMModuleRef *OutModule,
  37                                    char **OutMessage) {
  38   MemoryBufferRef Buf = unwrap(MemBuf)->getMemBufferRef();
  39   LLVMContext &Ctx = *unwrap(ContextRef);
  40
  41   Expected<std::unique_ptr<Module>> ModuleOrErr = parseBitcodeFile(Buf, Ctx);
  42   if (Error Err = ModuleOrErr.takeError()) {
  43     std::string Message;
  44     handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
  45       Message = EIB.message();
  46     });
  47     if (OutMessage)
  48       *OutMessage = strdup(Message.c_str());
  49     *OutModule = wrap((Module *)nullptr);
  50     return 1;
  51   }
  52
  53   *OutModule = wrap(ModuleOrErr.get().release());
  54   return 0;
  55 }
  56
  57 LLVMBool LLVMParseBitcodeInContext2(LLVMContextRef ContextRef,
  58                                     LLVMMemoryBufferRef MemBuf,
  59                                     LLVMModuleRef *OutModule) {
  60   MemoryBufferRef Buf = unwrap(MemBuf)->getMemBufferRef();
  61   LLVMContext &Ctx = *unwrap(ContextRef);
  62
  63   ErrorOr<std::unique_ptr<Module>> ModuleOrErr =
  64       expectedToErrorOrAndEmitErrors(Ctx, parseBitcodeFile(Buf, Ctx));
  65   if (ModuleOrErr.getError()) {
  66     *OutModule = wrap((Module *)nullptr);
  67     return 1;
  68   }
  69
  70   *OutModule = wrap(ModuleOrErr.get().release());
  71   return 0;
  72 }
  73
  74 /* Reads a module from the specified path, returning via the OutModule parameter
  75    a module provider which performs lazy deserialization. Returns 0 on success.
  76    Optionally returns a human-readable error message via OutMessage. */
  77 LLVMBool LLVMGetBitcodeModuleInContext(LLVMContextRef ContextRef,
  78                                        LLVMMemoryBufferRef MemBuf,
  79                                        LLVMModuleRef *OutM, char **OutMessage) {
  80   LLVMContext &Ctx = *unwrap(ContextRef);
  81   std::unique_ptr<MemoryBuffer> Owner(unwrap(MemBuf));
  82   Expected<std::unique_ptr<Module>> ModuleOrErr =
  83       getOwningLazyBitcodeModule(std::move(Owner), Ctx);
  84   // Release the buffer if we didn't take ownership of it since we never owned
  85   // it anyway.
  86   (void)Owner.release();
  87
  88   if (Error Err = ModuleOrErr.takeError()) {
  89     std::string Message;
  90     handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
  91       Message = EIB.message();
  92     });
  93     if (OutMessage)
  94       *OutMessage = strdup(Message.c_str());
  95     *OutM = wrap((Module *)nullptr);
  96     return 1;
  97   }
  98
  99   *OutM = wrap(ModuleOrErr.get().release());
 100
 101   return 0;
 102 }
 103
 104 LLVMBool LLVMGetBitcodeModuleInContext2(LLVMContextRef ContextRef,
 105                                         LLVMMemoryBufferRef MemBuf,
 106                                         LLVMModuleRef *OutM) {
 107   LLVMContext &Ctx = *unwrap(ContextRef);
 108   std::unique_ptr<MemoryBuffer> Owner(unwrap(MemBuf));
 109
 110   ErrorOr<std::unique_ptr<Module>> ModuleOrErr = expectedToErrorOrAndEmitErrors(
 111       Ctx, getOwningLazyBitcodeModule(std::move(Owner), Ctx));
 112   Owner.release();
 113
 114   if (ModuleOrErr.getError()) {
 115     *OutM = wrap((Module *)nullptr);
 116     return 1;
 117   }
 118
 119   *OutM = wrap(ModuleOrErr.get().release());
 120   return 0;
 121 }
 122
 123 LLVMBool LLVMGetBitcodeModule(LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM,
 124                               char **OutMessage) {
 125   return LLVMGetBitcodeModuleInContext(LLVMGetGlobalContext(), MemBuf, OutM,
 126                                        OutMessage);
 127 }
 128
 129 LLVMBool LLVMGetBitcodeModule2(LLVMMemoryBufferRef MemBuf,
 130                                LLVMModuleRef *OutM) {
 131   return LLVMGetBitcodeModuleInContext2(LLVMGetGlobalContext(), MemBuf, OutM);
 132 }