Coverage Report

Created: 2018-09-19 20:53

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/Serialization/ModuleFileExtension.h
Line
Count
Source (jump to first uncovered line)
1
//===-- ModuleFileExtension.h - Module File Extensions ----------*- C++ -*-===//
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
#ifndef LLVM_CLANG_SERIALIZATION_MODULEFILEEXTENSION_H
11
#define LLVM_CLANG_SERIALIZATION_MODULEFILEEXTENSION_H
12
13
#include "llvm/ADT/IntrusiveRefCntPtr.h"
14
#include <memory>
15
#include <string>
16
17
namespace llvm {
18
class BitstreamCursor;
19
class BitstreamWriter;
20
class hash_code;
21
class raw_ostream;
22
}
23
24
namespace clang {
25
26
class ASTReader;
27
class ASTWriter;
28
class Sema;
29
30
namespace serialization {
31
  class ModuleFile;
32
} // end namespace serialization
33
34
/// Metadata for a module file extension.
35
struct ModuleFileExtensionMetadata {
36
  /// The name used to identify this particular extension block within
37
  /// the resulting module file. It should be unique to the particular
38
  /// extension, because this name will be used to match the name of
39
  /// an extension block to the appropriate reader.
40
  std::string BlockName;
41
42
  /// The major version of the extension data.
43
  unsigned MajorVersion;
44
45
  /// The minor version of the extension data.
46
  unsigned MinorVersion;
47
48
  /// A string containing additional user information that will be
49
  /// stored with the metadata.
50
  std::string UserInfo;
51
};
52
53
class ModuleFileExtensionReader;
54
class ModuleFileExtensionWriter;
55
56
/// An abstract superclass that describes a custom extension to the
57
/// module/precompiled header file format.
58
///
59
/// A module file extension can introduce additional information into
60
/// compiled module files (.pcm) and precompiled headers (.pch) via a
61
/// custom writer that can then be accessed via a custom reader when
62
/// the module file or precompiled header is loaded.
63
class ModuleFileExtension {
64
public:
65
  virtual ~ModuleFileExtension();
66
67
  /// Retrieves the metadata for this module file extension.
68
  virtual ModuleFileExtensionMetadata getExtensionMetadata() const = 0;
69
70
  /// Hash information about the presence of this extension into the
71
  /// module hash code.
72
  ///
73
  /// The module hash code is used to distinguish different variants
74
  /// of a module that are incompatible. If the presence, absence, or
75
  /// version of the module file extension should force the creation
76
  /// of a separate set of module files, override this method to
77
  /// combine that distinguishing information into the module hash
78
  /// code.
79
  ///
80
  /// The default implementation of this function simply returns the
81
  /// hash code as given, so the presence/absence of this extension
82
  /// does not distinguish module files.
83
  virtual llvm::hash_code hashExtension(llvm::hash_code c) const;
84
85
  /// Create a new module file extension writer, which will be
86
  /// responsible for writing the extension contents into a particular
87
  /// module file.
88
  virtual std::unique_ptr<ModuleFileExtensionWriter>
89
  createExtensionWriter(ASTWriter &Writer) = 0;
90
91
  /// Create a new module file extension reader, given the
92
  /// metadata read from the block and the cursor into the extension
93
  /// block.
94
  ///
95
  /// May return null to indicate that an extension block with the
96
  /// given metadata cannot be read.
97
  virtual std::unique_ptr<ModuleFileExtensionReader>
98
  createExtensionReader(const ModuleFileExtensionMetadata &Metadata,
99
                        ASTReader &Reader, serialization::ModuleFile &Mod,
100
                        const llvm::BitstreamCursor &Stream) = 0;
101
};
102
103
/// Abstract base class that writes a module file extension block into
104
/// a module file.
105
class ModuleFileExtensionWriter {
106
  ModuleFileExtension *Extension;
107
108
protected:
109
  ModuleFileExtensionWriter(ModuleFileExtension *Extension)
110
0
    : Extension(Extension) { }
111
112
public:
113
  virtual ~ModuleFileExtensionWriter();
114
115
  /// Retrieve the module file extension with which this writer is
116
  /// associated.
117
0
  ModuleFileExtension *getExtension() const { return Extension; }
118
119
  /// Write the contents of the extension block into the given bitstream.
120
  ///
121
  /// Responsible for writing the contents of the extension into the
122
  /// given stream. All of the contents should be written into custom
123
  /// records with IDs >= FIRST_EXTENSION_RECORD_ID.
124
  virtual void writeExtensionContents(Sema &SemaRef,
125
                                      llvm::BitstreamWriter &Stream) = 0;
126
};
127
128
/// Abstract base class that reads a module file extension block from
129
/// a module file.
130
///
131
/// Subclasses
132
class ModuleFileExtensionReader {
133
  ModuleFileExtension *Extension;
134
135
protected:
136
  ModuleFileExtensionReader(ModuleFileExtension *Extension)
137
0
    : Extension(Extension) { }
138
139
public:
140
  /// Retrieve the module file extension with which this reader is
141
  /// associated.
142
0
  ModuleFileExtension *getExtension() const { return Extension; }
143
144
  virtual ~ModuleFileExtensionReader();
145
};
146
147
} // end namespace clang
148
149
#endif // LLVM_CLANG_FRONTEND_MODULEFILEEXTENSION_H