LLVM  10.0.0svn
YAMLRemarkSerializer.h
Go to the documentation of this file.
1 //===-- YAMLRemarkSerializer.h - YAML Remark serialization ---*- C++ -*-===//
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 // This file provides an interface for serializing remarks to YAML.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_REMARKS_YAML_REMARK_SERIALIZER_H
14 #define LLVM_REMARKS_YAML_REMARK_SERIALIZER_H
15 
18 
19 namespace llvm {
20 namespace remarks {
21 
22 /// Serialize the remarks to YAML. One remark entry looks like this:
23 /// --- !<TYPE>
24 /// Pass: <PASSNAME>
25 /// Name: <REMARKNAME>
26 /// DebugLoc: { File: <SOURCEFILENAME>, Line: <SOURCELINE>,
27 /// Column: <SOURCECOLUMN> }
28 /// Function: <FUNCTIONNAME>
29 /// Args:
30 /// - <KEY>: <VALUE>
31 /// DebugLoc: { File: <FILE>, Line: <LINE>, Column: <COL> }
32 /// ...
34  /// The YAML streamer.
35  yaml::Output YAMLOutput;
36 
39 
40  void emit(const Remark &Remark) override;
41  std::unique_ptr<MetaSerializer>
43  Optional<StringRef> ExternalFilename = None) override;
44 
45  static bool classof(const RemarkSerializer *S) {
46  return S->SerializerFormat == Format::YAML;
47  }
48 
49 protected:
53 };
54 
57 
59  : MetaSerializer(OS), ExternalFilename(ExternalFilename) {}
60 
61  void emit() override;
62 };
63 
64 /// Serialize the remarks to YAML using a string table. An remark entry looks
65 /// like the regular YAML remark but instead of string entries it's using
66 /// numbers that map to an index in the string table.
68  /// Wether we already emitted the metadata in standalone mode.
69  /// This should be set to true after the first invocation of `emit`.
70  bool DidEmitMeta = false;
71 
73  : YAMLRemarkSerializer(Format::YAMLStrTab, OS, Mode) {
74  // We always need a string table for this type of serializer.
75  StrTab.emplace();
76  }
79  : YAMLRemarkSerializer(Format::YAMLStrTab, OS, Mode, std::move(StrTab)) {}
80 
81  /// Override to emit the metadata if necessary.
82  void emit(const Remark &Remark) override;
83 
84  std::unique_ptr<MetaSerializer>
86  Optional<StringRef> ExternalFilename = None) override;
87 
88  static bool classof(const RemarkSerializer *S) {
90  }
91 };
92 
94  /// The string table is part of the metadata.
96 
98  Optional<StringRef> ExternalFilename,
99  const StringTable &StrTab)
100  : YAMLMetaSerializer(OS, ExternalFilename), StrTab(StrTab) {}
101 
102  void emit() override;
103 };
104 
105 } // end namespace remarks
106 } // end namespace llvm
107 
108 #endif /* LLVM_REMARKS_REMARK_SERIALIZER_H */
const NoneType None
Definition: None.h:23
Serialize the remarks to YAML using a string table.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
std::unique_ptr< MetaSerializer > metaSerializer(raw_ostream &OS, Optional< StringRef > ExternalFilename=None) override
Return the corresponding metadata serializer.
static bool classof(const RemarkSerializer *S)
static bool classof(const RemarkSerializer *S)
Format SerializerFormat
The format of the serializer.
YAMLStrTabRemarkSerializer(raw_ostream &OS, SerializerMode Mode)
Format
The format used for serializing/deserializing remarks.
Definition: RemarkFormat.h:25
Definition: BitVector.h:937
A remark type used for both emission and parsing.
Definition: Remark.h:67
YAMLRemarkSerializer(raw_ostream &OS, SerializerMode Mode, Optional< StringTable > StrTab=None)
SerializerMode Mode
The serialization mode.
The string table used for serializing remarks.
YAMLMetaSerializer(raw_ostream &OS, Optional< StringRef > ExternalFilename)
YAMLStrTabMetaSerializer(raw_ostream &OS, Optional< StringRef > ExternalFilename, const StringTable &StrTab)
void emit(const Remark &Remark) override
Emit a remark to the stream.
Serialize the remarks to YAML.
This is the base class for a remark metadata serializer.
raw_ostream & OS
The open raw_ostream that the remark diagnostics are emitted to.
This is the base class for a remark serializer.
YAMLStrTabRemarkSerializer(raw_ostream &OS, SerializerMode Mode, StringTable StrTab)
const StringTable & StrTab
The string table is part of the metadata.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
Optional< StringTable > StrTab
The string table containing all the unique strings used in the output.
yaml::Output YAMLOutput
The YAML streamer.