Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/tools/clang/lib/Frontend/TestModuleFileExtension.cpp
Line
Count
Source
1
//===-- TestModuleFileExtension.cpp - Module Extension Tester -------------===//
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
#include "TestModuleFileExtension.h"
10
#include "clang/Frontend/FrontendDiagnostic.h"
11
#include "clang/Serialization/ASTReader.h"
12
#include "llvm/ADT/Hashing.h"
13
#include "llvm/Bitcode/BitstreamWriter.h"
14
#include "llvm/Support/raw_ostream.h"
15
#include <cstdio>
16
using namespace clang;
17
using namespace clang::serialization;
18
19
12
TestModuleFileExtension::Writer::~Writer() { }
20
21
void TestModuleFileExtension::Writer::writeExtensionContents(
22
       Sema &SemaRef,
23
12
       llvm::BitstreamWriter &Stream) {
24
12
  using namespace llvm;
25
12
26
12
  // Write an abbreviation for this record.
27
12
  auto Abv = std::make_shared<llvm::BitCodeAbbrev>();
28
12
  Abv->Add(BitCodeAbbrevOp(FIRST_EXTENSION_RECORD_ID));
29
12
  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of characters
30
12
  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));   // message
31
12
  auto Abbrev = Stream.EmitAbbrev(std::move(Abv));
32
12
33
12
  // Write a message into the extension block.
34
12
  SmallString<64> Message;
35
12
  {
36
12
    auto Ext = static_cast<TestModuleFileExtension *>(getExtension());
37
12
    raw_svector_ostream OS(Message);
38
12
    OS << "Hello from " << Ext->BlockName << " v" << Ext->MajorVersion << "."
39
12
       << Ext->MinorVersion;
40
12
  }
41
12
  uint64_t Record[] = {FIRST_EXTENSION_RECORD_ID, Message.size()};
42
12
  Stream.EmitRecordWithBlob(Abbrev, Record, Message);
43
12
}
44
45
TestModuleFileExtension::Reader::Reader(ModuleFileExtension *Ext,
46
                                        const llvm::BitstreamCursor &InStream)
47
  : ModuleFileExtensionReader(Ext), Stream(InStream)
48
13
{
49
13
  // Read the extension block.
50
13
  SmallVector<uint64_t, 4> Record;
51
26
  while (
true26
) {
52
26
    llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
53
26
    switch (Entry.Kind) {
54
13
    case llvm::BitstreamEntry::SubBlock:
55
13
    case llvm::BitstreamEntry::EndBlock:
56
13
    case llvm::BitstreamEntry::Error:
57
13
      return;
58
13
59
13
    case llvm::BitstreamEntry::Record:
60
13
      break;
61
13
    }
62
13
63
13
    Record.clear();
64
13
    StringRef Blob;
65
13
    unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
66
13
    switch (RecCode) {
67
13
    case FIRST_EXTENSION_RECORD_ID: {
68
13
      StringRef Message = Blob.substr(0, Record[0]);
69
13
      fprintf(stderr, "Read extension block message: %s\n",
70
13
              Message.str().c_str());
71
13
      break;
72
26
    }
73
26
    }
74
26
  }
75
13
}
76
77
13
TestModuleFileExtension::Reader::~Reader() { }
78
79
16
TestModuleFileExtension::~TestModuleFileExtension() { }
80
81
ModuleFileExtensionMetadata
82
40
TestModuleFileExtension::getExtensionMetadata() const {
83
40
  return { BlockName, MajorVersion, MinorVersion, UserInfo };
84
40
}
85
86
llvm::hash_code TestModuleFileExtension::hashExtension(
87
18
                  llvm::hash_code Code) const {
88
18
  if (
Hashed18
) {
89
8
    Code = llvm::hash_combine(Code, BlockName);
90
8
    Code = llvm::hash_combine(Code, MajorVersion);
91
8
    Code = llvm::hash_combine(Code, MinorVersion);
92
8
    Code = llvm::hash_combine(Code, UserInfo);
93
8
  }
94
18
  
95
18
  return Code;
96
18
}
97
98
std::unique_ptr<ModuleFileExtensionWriter>
99
12
TestModuleFileExtension::createExtensionWriter(ASTWriter &) {
100
12
  return std::unique_ptr<ModuleFileExtensionWriter>(new Writer(this));
101
12
}
102
103
std::unique_ptr<ModuleFileExtensionReader>
104
TestModuleFileExtension::createExtensionReader(
105
  const ModuleFileExtensionMetadata &Metadata,
106
  ASTReader &Reader, serialization::ModuleFile &Mod,
107
  const llvm::BitstreamCursor &Stream)
108
15
{
109
15
  assert(Metadata.BlockName == BlockName && "Wrong block name");
110
15
  if (std::make_pair(Metadata.MajorVersion, Metadata.MinorVersion) !=
111
15
        std::make_pair(MajorVersion, MinorVersion)) {
112
2
    Reader.getDiags().Report(Mod.ImportLoc,
113
2
                             diag::err_test_module_file_extension_version)
114
2
      << BlockName << Metadata.MajorVersion << Metadata.MinorVersion
115
2
      << MajorVersion << MinorVersion;
116
2
    return nullptr;
117
2
  }
118
13
119
13
  return std::unique_ptr<ModuleFileExtensionReader>(
120
13
                                                    new TestModuleFileExtension::Reader(this, Stream));
121
13
}