Coverage Report

Created: 2017-10-03 07:32

/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
}