[clang-doc] Implement reducer portion of the frontend framework

[juliehockett]

Summary

Implements a simple, in-memory reducer for the mapped output of the initial tool. This creates a collection object for storing the deduplicated infos on each declaration, and populates that from the mapper output. The collection object is serialized to LLVM bitstream. On reading each serialized output, it checks to see if a merge is necessary and if so, merges the new info with the existing info (prefering the existing one if conflicts exist). Also implements the bitcode reader.

For a more detailed overview of the tool, see the design document on the mailing list: RFC: clang-doc proposal

[juliehockett]

Moving the entire implementation of the bitcode reader to this patch (from the mapper patch, here) and cleaning up implementation

[juliehockett]

Updating for parent diff changes

[Eugene.Zelenko]

Please run Clang-format and Clang-tidy modernize.

clang-doc/BitcodeReader.h

36 ↗

(On Diff #135520)

Please use = default;

[juliehockett]

Cleaning up some and updating based on changes to the parent diff.

[juliehockett]

Updating for parent diff & refactoring reader.

[lebedev.ri]

Thank you for working on this!

Finally trying to review this...
I must say i'm really not fond of the test 'changes'.

But some initial comments added:

clang-doc/BitcodeReader.cpp

19 ↗

(On Diff #136793)

I think all these SmallString can be one llvm::SmallVectorImpl<char>?

454 ↗

(On Diff #136793)

RecordNames is basically not kept between the reuses of ClangDocBitcodeReader, but is also not actually properly gc'd.
Also, this uses BI_FIRST / BI_LAST, which means the versioning is actually absolutely required...
Also, RecordNames isn't actually used anywhere later in this code.

So, Is that needed for the next patches? Or why read this at all?

clang-doc/BitcodeReader.h

36 ↗

(On Diff #136793)

Bits is not an output parameter, but just a const input parameter?
I think it would be cleaner to use StringRef, to avoid depending on the actual size of the small-size.

46 ↗

(On Diff #136793)

Please separate those tree functions and this template function with one newline.

48 ↗

(On Diff #136793)

T &&I looks super vague.
T is {something}Info, which is inherited from Info base-class.
Maybe something like InfoT &&I ?

clang-doc/Reducer.cpp

19 ↗

(On Diff #136793)

As far as i can tell, Reader isn't required to be kept out here.
It seems it's not used to retain any internal state.
The only obvious reason to keep it, is to avoid de-allocating and then re-allocating the memory each time.

I'm wondering if it would be better to move it into the lambda.
Also, why is it prefixed with the doc::? We are in that namespace already.

Then, you will also be able to get rid of llvm::BitstreamCursor &Stream params in the ClangDocBitcodeReader member functions, like with ClangDocBitcodeWriter.

clang-doc/Representation.h

193 ↗

(On Diff #136793)

Similarly, i think those should be SmallVectorImpl (i assume those are output params, too?)

test/clang-doc/mapper-class-in-class.cpp

1 ↗

(On Diff #136793)

What's up with all tests being deleted? That is rather disturbing.
I would expect the merge phase to be disable-able, if only just for the testing purposes.

[juliehockett]

Adding in support for mapper tests and addressing comments.

[juliehockett]

clang-doc/BitcodeReader.cpp

19 ↗

(On Diff #136793)

No, since there's not an implicit converter from llvm::SmallVectorImpl<char> to StringRef. I templatized it on the size though, so it's only one function now.

clang-doc/Representation.h

193 ↗

(On Diff #136793)

Yup -- the pointer inside gets set.

[lebedev.ri]

Once the base differential firmly lands, could you please rebase this so the review could continue?

[juliehockett]

Rebasing and updating.

[lebedev.ri]

It's good to finally have the initial block firmly landed, congratulations.

Trying to review this...
Some initial thoughts.

clang-doc/BitcodeReader.cpp

19 ↗

(On Diff #136793)

Are you sure?
https://godbolt.org/g/wD1FKD

That isn't pretty, but i think it beats templating in this case..

27 ↗

(On Diff #139644)

Ok, i don't understand what is going on here.
Where is this E defined?
This looks like [0] is the number of elements to read (always 20, sha1 blob?),
and it copies Record[1]..Record[20] to Field[0]..Field[19] ?
I think this can/should be rewritten clearer..

clang-doc/BitcodeReader.h

33 ↗

(On Diff #139644)

Similarly, i think this should be

bool readBitstream(InfoSet &IS);

44 ↗

(On Diff #139644)

As far as i can see this should be

template <typename TInfo>
bool readBlockToInfo(unsigned ID, InfoSet &IS);

clang-doc/BitcodeWriter.h

142 ↗

(On Diff #139644)

And here too, it does not make much sense to call it with empty std::unique_ptr<>, so maybe

void emitInfoSet(InfoSet &ISet);

?

clang-doc/Reducer.cpp

18 ↗

(On Diff #139644)

I can see that you may return nullptr; in case of error here, thus it's std::unique_ptr<>
InfoSet internally is just a few std::vector<>s, so it should std::move() efficiently.
I'm wondering if llvm::Optional<InfoSet> would work too?

clang-doc/Representation.cpp

19 ↗

(On Diff #139644)

I though this was changed, and the non-stringified, original binary version of sha1 was emitted into bitcode?

28 ↗

(On Diff #139644)

???
Where *to* is it moved?

40 ↗

(On Diff #139644)

All these mergeInfo(): the second param, Info &R should probably be Info &&R.
(but not mergeInfoBase()/mergeSymbolInfoBase())

98 ↗

(On Diff #139644)

Seeing how many std::move()'ing is happening in those mergeInfo(), i think you want to move I, not pass as reference.
Especially since it is already &&I in this InfoSet::insert() function.

clang-doc/Representation.h

30 ↗

(On Diff #139644)

Please add a comment explaining that SymbolID is sha1, and not hex-string of sha1.

135 ↗

(On Diff #139644)

Why is the move constructor explicitly defined?
Unless i'm missing something, the default one would do exactly the same.
https://godbolt.org/g/XqsRuX

clang-doc/tool/ClangDocMain.cpp

130 ↗

(On Diff #139644)

That is the same small-size used in static std::string serialize(T &I).
Some statistic is needed, bu i think this one can be bumped somewhat right away.

141 ↗

(On Diff #139644)

This shares some code with if(DumpMapperResult).
Perhaps you could refactor it slightly, to reduce code duplication?

[juliehockett]

Addressing comments

[Eugene.Zelenko]

Please mention new tool in Release Notes and use :doc: to refer to its manual.

[lebedev.ri]

It's surprisingly difficult to review this :/
Just by itself the logic is simple, but the amount of blocks/records/record types is kinda demoralizing.
I really hope it will be possible to somehow tablegen this later.

clang-doc/BitcodeReader.cpp

363 ↗

(On Diff #139869)

Hmm, why does this function exist?
The only difference from the previous one is the std::unique_ptr<>.

488 ↗

(On Diff #139869)

This signature should be in one place (header?), and then just used here and in ClangDocBitcodeWriter::emitHeader()

clang-doc/BitcodeWriter.cpp

537 ↗

(On Diff #139869)

It should be void ClangDocBitcodeWriter::emitInfoSet(const InfoSet &ISet) { then.

clang-doc/BitcodeWriter.h

129 ↗

(On Diff #139869)

Isn't that the opposite of what was that assert supposed to do?
It would have been better to just // disable it, and add a FIXME note.

clang-doc/tool/ClangDocMain.cpp

138 ↗

(On Diff #139869)

4096?

[juliehockett]

Small fixes to address comments

[juliehockett]

clang-doc/BitcodeReader.cpp

27 ↗

(On Diff #139644)

Record[0] holds the size of the array -- in this case, 20 -- in the bitstream representation of the array (see the array section here). So, yes, it copies Record[1]...[20] to Field[0]...[19]. Not sure how that can be rewritten more clearly, but I'll add a clarifying comment!

clang-doc/BitcodeWriter.h

129 ↗

(On Diff #139869)

I'm not sure I'm understanding you -- my understanding was that it existed to check that the record size was large enough.

clang-doc/Reducer.cpp

18 ↗

(On Diff #139644)

Doesn't llvm::Optional imply that it *could* validly not exist though? This is trying to express here that that isn't a valid state.

clang-doc/Representation.h

135 ↗

(On Diff #139644)

It's there (as is the CommentInfo one) because otherwise it was throwing errors. It appears that a copy constructor is called somewhere if this isn't specified.

[lebedev.ri]

clang-doc/BitcodeWriter.h

129 ↗

(On Diff #139869)

https://reviews.llvm.org/D41102?id=136520#inline-384087

#ifndef NDEBUG // Don't want explicit dtor unless needed
~ClangDocBitcodeWriter() {
  // Check that the static size is large-enough.
  assert(Record.capacity() == BitCodeConstants::RecordSize);
}
#endif

I.e. it checked that it still only had the static size, and did not transform into normal vector with data stored on heap-allocated buffer.

[lebedev.ri]

clang-doc/BitcodeWriter.h

129 ↗

(On Diff #139869)

Ok, let me use more words this time.
There are several storage container types with contiguous storage:

• array - fixed-size stack storage, size == capacity == compile-time constant
• vector - dynamic heap storage, size <= capacity
• smallvector - fixed-size stack storage, and if the data does not fit, it degrades into the vector.

But there is also one more option:

• fixedvector - which is a array - has only fixed-size stack storage (capacity == compile-time constant), but with vector-like interface, i.e. size <= capacity, and size can be changed at run-time.

In llvm, i'm not aware of existence of llvm::fixedvector, so that assert was ensuring that the smallvector behaved like the fixedvector - it only had the fixed-size stack storage, and 'did not have' the heap buffer.

This is a kinda ugly hack, but i think the current assert clearly does something different...

Does that make any sense?

clang-doc/Representation.cpp

28 ↗

(On Diff #139972)

This was changed, but no test changes followed.
Needs more tests. The test coverage is clearly bad.

[juliehockett]

Fixing assert on vector size.

[sammccall]

OK, I didn't get through all the detail, but we should talk about the MR stuff today :)

clang-doc/BitcodeReader.cpp

25 ↗

(On Diff #140275)

why is this true?
i.e. why can't I produce a malformed bitcode file that causes this assertion to fail?
(My usual understanding is that a failed assert is meant to indicate a programming error, if it means something else here like "malformed file" you should probably document that if you're sure it's what you want)

42 ↗

(On Diff #140275)

Similarly, what guarantees Record[0] is in-range for AccessSpecifier? casting an out-of-range integer to an enum results in UB.

clang-doc/BitcodeReader.h

11 ↗

(On Diff #140275)

nit: *from* LLVM bitcode, or am I missing something?

29 ↗

(On Diff #140275)

I found the implementation here a bit hard to understand at first, mostly because the state/invariants/responsibilities of each method weren't obvious to me.
Left some suggestions below to document these a bit more.

However many of these seem to in practice only share the Record buffer. It seems making this an explicit parameter would let you make these free functions, hiding them from the header and avoiding any possibility of spooky side-channel interactions. Up to you of course.

46 ↗

(On Diff #140275)

I think this needs some elaboration :-)
e.g. Populates Record with the decoded record, and then calls one of the parseRecord overloads.

In general the data flow between these methods seems a little obscured by having Record be a field rather than a parameter as ID/Blob are.
(Incidentally I don't think you gain anything here from the use of SmallVector over std::vector, which is easier to type, but it doesn't really matter)

49 ↗

(On Diff #140275)

comment for these methods e.g. Populates the appropriate field of the Info object based on a decoded record whose content is in Record.

59 ↗

(On Diff #140275)

Comment for these like "decodes the blob part of a record" - or just rename these decodeBlob or similar?

clang-doc/Reducer.cpp

17 ↗

(On Diff #140275)

A little bit of context to document here: the fact that ToolResults values are bit-encoded InfoSets describing each TU in the codebase. (I think?)

(Also, why not return InfoSet by value?)

23 ↗

(On Diff #140275)

I don't see where any actual merging is happening.
Say we process TU 1 which has a decl of foo() with a doc comment, and TU 2 which defines foo(). Now we're going to have something like:
ToolResults = {
"tu1": "...bitcode...foo().../*does foo*/",
"tu2": "...bitcode...foo()...Foo.cpp:53",
}
the first readBitstream call is going to ultimately call StoreData(UniqueInfos->Functions), which appends a new function to the array
then the second readBitstream call will do the same thing, and you have an InfoSet with two copies of foo()

what am I missing?

clang-doc/Reducer.h

21 ↗

(On Diff #140275)

This doesn't quite look like the typical reduce pattern. (And there's no framework or guidance for MRs in libtooling so this isn't surprising or maybe even a problem.

When the mapper emits its values, it usually chooses the keys so that a non-trivial merge is only required among values with the same key. (e.g. USR here)
This does two things:

1. it makes it really easy to parallelize: after the mappers run in parallel, the data is grouped by key and all the reducers can run in parallel
2. it simplifies the reducer code a lot, as it only has to deal with a single entity (e.g. function) at a time.

So conceptually instead of being a function(vector<InfoSet>) --> InfoSet, it's a function(USR, vector<FunctionInfo>) --> FunctionInfo.
The signature you've got here doesn't actually preclude 1), but it's unclear whether you expect it to be used this way. (i.e. do all the InfoSets being passed here actually contain only a single, identical entity?).

That said - does this actually matter? If you want to scale to large codebases, loading all your Infos into one InfoSet in memory is something to avoid. It's important to be able to process the symbols separately, both for parallelism and to avoid atomic tasks that are too big for one machine.
If you want to do this, then modelling the data unit as "one symbol of some kind" rather than "an arbitrary set of symbols" is much more natural. You no longer need "what is this symbol" in the value and to decode it over and over, instead you put it in the key.
So conceptually you have something like:
key="FUNCTION/::foo(int)", value = "COMMENT=does foo;PARAMS=[length]"
Your reducer merges the values for the same key without having to touch the key, and then the final documentation generator can run over the values inde

If you don't care about big codebases, I can't think of a strong reason to care. I like the conceptual framework of MR, but it's not necessary.

clang-doc/Representation.h

135 ↗

(On Diff #139644)

you can define the move constructor as = default, and copy as = delete. The intent is clear, but you save some typing.

207 ↗

(On Diff #140275)

This class is central, has a vague name, and is undocumented :-)

I gather this is the collection that describes the whole codebase. Something like CodebaseInfo might be a little more descriptive (though also misleading, as it doesn't inherit Info). But the name is OK as long as it's documented.

220 ↗

(On Diff #140275)

So this implementation relies on InfoIndex and having the whole codebase in one InfoSet in memory.
If you want to scale past having everything in-memory, this needs to be part of the MR too.

Since you're at euroLLVM, let's find a chance to chat about it today, we should make a decision about whether "all fits in memory" is a simplifying assumption you want.

[juliehockett]

Reorganizing and streamlining, particularly in decoupling the reader from the reduce process and redesigning a bit to allow for more flexible reducing. Currently implements an in-memory reducer, but could (theoretically) be extended.

[juliehockett]

clang-doc/BitcodeReader.h

59 ↗

(On Diff #140275)

In general they decode the record abbrev of the field, which is a single blob in many, but not all, cases. I've changed it to decodeRecord, but is too similar to the above?

clang-doc/BitcodeWriter.h

129 ↗

(On Diff #139869)

Ah, yes. I see what you're trying to do, but the issue with that is it assumes that the record must be a certain size (or smaller). However, there is no guarantee of the size of the record (i.e. there may and will be records of variable size getting written), so it's not unreasonable to think that the record may need to be resized to accommodate that.

[lebedev.ri]

clang-doc/BitcodeWriter.h

129 ↗

(On Diff #139869)

However, there is no guarantee of the size of the record (i.e. there may and will be records of variable size getting written), so it's not unreasonable to think that the record may need to be resized to accommodate that.

Yes, but *currently* that was correct assumption.
All variable-length records (well, blobs) are (were?) emitted directly, without using this intermediate Record container.

[sammccall]

clang-doc/Index.h

28 ↗

(On Diff #144011)

What is this interface for? It looks like none of the functions are ever called through the interface.

If the intent is to abstract away a MR framework, I don't think this achieves that - multimachine MR frameworks have their "index" distributed and probably won't have a "reduce" function you can call with these semantics.

Consider just moving the in-memory reduction to the main file (which isn't portable across MR abstractions anyway) and avoiding abstractions there:

StringMap<std::vector<std::unique_ptr<Info>>>>  MapOutput;
// populate MapOutput as you currently do in inMemoryReduceResults
for (const auto &Group : MapOutput)
  Write(Group.first, reduceInfos(std::move(Group.second)));

clang-doc/Reducer.cpp

18 ↗

(On Diff #144011)

TYPE is unused?

clang-doc/Representation.cpp

1 ↗

(On Diff #144011)

this is important/subtle logic, and there are no comments (particularly about motivating how specific fields are merged)!

15 ↗

(On Diff #144011)

why this, rather than actual assignment? (comments!)

20 ↗

(On Diff #144011)

why would you ever assign() rather than move()

26 ↗

(On Diff #144011)

why this pattern of "assign if empty" for these types?

39 ↗

(On Diff #144011)

what if there are duplicatel?

53 ↗

(On Diff #144011)

is plain concatenation of comments what you want?

clang-doc/Representation.h

75 ↗

(On Diff #144011)

consider std::tie(A, B) == std::tie(Other.A, Other.B)

79 ↗

(On Diff #144011)

do you really need !=?
if so, prefer to define it as !(*this == Other) to avoid redundancy.

159 ↗

(On Diff #144011)

should this be a copy constructor? (reference should be const)

162 ↗

(On Diff #144011)

So having this "overriding" that's not virtual seems like asking for trouble: if you accidentally deref a unique_ptr<Info> and compare it, you'll get the base behavior which should probably never be called directly.

Consider naming this mergeBase and making it protected.

[juliehockett]

Cleaning up and clarifying the merging process, and addressing comments

[juliehockett]

clang-doc/Representation.cpp

53 ↗

(On Diff #144011)

Yes, in this case, as they aren't comment strings but vectors of comment infos.

[juliehockett]

This will break things in clang-tools-extra without D46615, so I'm going to hold off landing this until that goes through

[juliehockett]

In D43341#1093117, @juliehockett wrote:

This will break things in clang-tools-extra without D46615, so I'm going to hold off landing this until that goes through

Oops wrong patch disregard

[juliehockett]

Ping....any more thoughts?

[juliehockett]

ping

[ioeric]

The reduce logic seems to be in a good shape. Some nits and questions inlined.

clang-doc/Reducer.cpp

19 ↗

(On Diff #144948)

It seems that you could use a template function?

24 ↗

(On Diff #144948)

Do we really want to give up all infos when one bad info/merge is present?

clang-doc/Representation.h

138 ↗

(On Diff #144948)

Shouldn't USR be SymbolID() by default?

146 ↗

(On Diff #144948)

It's a bit awkward that users have to dispatch from info types to the corresponding merge function (as in Reducer.cpp). I think it would make users' life easier if the library handles the dispatching.

I wonder if something like the following would be better:

struct Info {
    std::unique_ptr<Info> merge(const Indo& LHS, const Info& RHS);
};
// A standalone function.
std::unique_ptr<Info> mergeInfo(const Info &LHS, const Info& RHS) {
  // merge base info.
  ...
  // merge subclass infos.
  assert(LHS.IT == RHS.IT); // or return nullptr
  switch (LHS.IT) {
   ... 
    return Namespace::merge(LHS, RHS);
  } 
}

struct NamespaceInfo : public Info {
  std::unique_ptr<Info> merge(LHS, RHS);
};

The unhandled switch case warning in compiler would help you catch unimplemented merge when new info types are added.

clang-doc/tool/ClangDocMain.cpp

60 ↗

(On Diff #144948)

If this only dumps the intermediate results, should we call it something like dump-intermediate instead, to avoid confusion with final results?

148 ↗

(On Diff #144948)

Print an error message on error?

154 ↗

(On Diff #144948)

Could you add a brief comment explaining what key and value are?

161 ↗

(On Diff #144948)

nit: remove debug logging?

170 ↗

(On Diff #144948)

nit: maybe also output the number of entries collected in the map?

181 ↗

(On Diff #144948)

(Sorry that I might be missing context here.)

Could you please explain the incentive for dumping each info group to one bc file? If the key identifies a symbol (e.g. USR), wouldn't this result in a bitcode file being created for each symbol? This doesn't seem very scalable.

[juliehockett]

Reworking the reducer interface a bit to address comments.

[juliehockett]

clang-doc/Representation.h

138 ↗

(On Diff #144948)

It actually is garbage by default -- doing this zeroed it out.

146 ↗

(On Diff #144948)

Sort of addressed in this update. There's an issue with where we allocate the return pointer, because we need to know the type of info at allocation time -- let me know if what's here now is too far off of what you were suggesting.

clang-doc/tool/ClangDocMain.cpp

181 ↗

(On Diff #144948)

Yes, it would. This is mostly for debugging, since there's not really any tools outside the clang system that would actually want/be able to use this information.

[ioeric]

clang-doc/BitcodeReader.cpp

553 ↗

(On Diff #148678)

Convert this to a template function?

clang-doc/Reducer.cpp

19 ↗

(On Diff #148678)

Now that merging is implemented in the info library, reduceInfos doesn't seem to be necessary.

I'd suggest moving writeInfo closer to the bitcode writer library and get rid of the Reducer.h/cpp.

23 ↗

(On Diff #148678)

I think a more canonical form to pass in an output buffer is via llvm::raw_ostream, and then callers can use llvm::raw_string_ostream.

clang-doc/Representation.cpp

30 ↗

(On Diff #148678)

Macros are generally discouraged. Could you make this a function in Info e.g. Info::mergeable(const Info &Other). And sub-classes can simply can asssert(mergeable(Other)).

59 ↗

(On Diff #148678)

Use llvm::Expected<std::unique_ptr<Info>> (e.g. llvm::make_error<StringError>(...)) for error handling and let callers decide how to handle the error (e.g. llvm::errs() << llvm::toString(Err)).

clang-doc/Representation.h

216 ↗

(On Diff #148678)

Please elaborate a bit on the contract e.g. all values should have the same type; otherweise ...

217 ↗

(On Diff #148678)

nit: s/Value/Values/ or Infos

146 ↗

(On Diff #144948)

Thanks!

I thin what you have is also fine, as long as it's easy to maintain when adding new info types.

clang-doc/tool/ClangDocMain.cpp

181 ↗

(On Diff #144948)

Ok, is there any plan to convert intermediate result to final result and output in a more accessible format? If so, please add a FIXME somewhere just to be clearer.

176 ↗

(On Diff #148678)

Rather then replace the values in MapOutput, it would probably be clearer if you store the reduced infos into a different container e.g. Reduced.

docs/ReleaseNotes.rst

61 ↗

(On Diff #148678)

Are these changes relevant to this patch?

[juliehockett]

Fixing comments

clang-doc/tool/ClangDocMain.cpp

181 ↗

(On Diff #144948)

That's what the next patch set is (to generate YAML).

[ioeric]

lgtm with just a few more nits.

clang-doc/BitcodeWriter.cpp

484 ↗

(On Diff #149371)

Nit: EMITINFO is a bit confusing with writeInfo. Are they doing the same thing (emit sounds like write)? You might want to rename either of them. While you are here, it might also make sense to clear up the MACRO :)

clang-doc/Representation.cpp

57 ↗

(On Diff #149371)

nit: std::error_code() is usually used to indicate no error. You could use llvm::inconvertibleErrorCode().

clang-doc/tool/ClangDocMain.cpp

181 ↗

(On Diff #144948)

Sure. I think a FIXME should be in place if the feature is not already there.

68 ↗

(On Diff #149371)

nit: s/current option/default option/

68 ↗

(On Diff #149371)

consider using enum type options. Example: https://github.com/llvm-mirror/clang-tools-extra/blob/master/include-fixer/tool/ClangIncludeFixer.cpp#L85

178 ↗

(On Diff #149371)

Shouldn't we continue to the next group if reduction goes wrong for the current group?

clang-tools-extra/trunk/clang-doc/BitcodeReader.h

+//===--  BitcodeReader.h - ClangDoc Bitcode Reader --------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a reader for parsing the clang-doc internal
+// representation from LLVM bitcode. The reader takes in a stream of bits and
+// generates the set of infos that it represents.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_BITCODEREADER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_BITCODEREADER_H
+
+#include "BitcodeWriter.h"
+#include "Representation.h"
+#include "clang/AST/AST.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Bitcode/BitstreamReader.h"
+
+namespace clang {
+namespace doc {
+
+// Class to read bitstream into an InfoSet collection
+class ClangDocBitcodeReader {
+public:
+  ClangDocBitcodeReader(llvm::BitstreamCursor &Stream) : Stream(Stream) {}
+
+  // Main entry point, calls readBlock to read each block in the given stream.
+  std::vector<std::unique_ptr<Info>> readBitcode();
+
+private:
+  enum class Cursor { BadBlock = 1, Record, BlockEnd, BlockBegin };
+
+  // Top level parsing
+  bool validateStream();
+  bool readVersion();
+  bool readBlockInfoBlock();
+
+  // Read a block of records into a single Info struct, calls readRecord on each
+  // record found.
+  template <typename T> bool readBlock(unsigned ID, T I);
+
+  // Step through a block of records to find the next data field.
+  template <typename T> bool readSubBlock(unsigned ID, T I);
+
+  // Read record data into the given Info data field, calling the appropriate
+  // parseRecord functions to parse and store the data.
+  template <typename T> bool readRecord(unsigned ID, T I);
+
+  // Allocate the relevant type of info and add read data to the object.
+  template <typename T> std::unique_ptr<Info> createInfo(unsigned ID);
+
+  // Helper function to step through blocks to find and dispatch the next record
+  // or block to be read.
+  Cursor skipUntilRecordOrBlock(unsigned &BlockOrRecordID);
+
+  // Helper function to set up the approriate type of Info.
+  std::unique_ptr<Info> readBlockToInfo(unsigned ID);
+
+  llvm::BitstreamCursor &Stream;
+  Optional<llvm::BitstreamBlockInfo> BlockInfo;
+  FieldId CurrentReferenceField;
+};
+
+} // namespace doc
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_BITCODEREADER_H

clang-tools-extra/trunk/clang-doc/BitcodeReader.cpp

+//===--  BitcodeReader.cpp - ClangDoc Bitcode Reader ------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "BitcodeReader.h"
+#include "llvm/ADT/IndexedMap.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace clang {
+namespace doc {
+
+using Record = llvm::SmallVector<uint64_t, 1024>;
+
+bool decodeRecord(Record R, llvm::SmallVectorImpl<char> &Field,
+                  llvm::StringRef Blob) {
+  Field.assign(Blob.begin(), Blob.end());
+  return true;
+}
+
+bool decodeRecord(Record R, SymbolID &Field, llvm::StringRef Blob) {
+  if (R[0] != BitCodeConstants::USRHashSize)
+    return false;
+
+  // First position in the record is the length of the following array, so we
+  // copy the following elements to the field.
+  for (int I = 0, E = R[0]; I < E; ++I)
+    Field[I] = R[I + 1];
+  return true;
+}
+
+bool decodeRecord(Record R, bool &Field, llvm::StringRef Blob) {
+  Field = R[0] != 0;
+  return true;
+}
+
+bool decodeRecord(Record R, int &Field, llvm::StringRef Blob) {
+  if (R[0] > INT_MAX)
+    return false;
+  Field = (int)R[0];
+  return true;
+}
+
+bool decodeRecord(Record R, AccessSpecifier &Field, llvm::StringRef Blob) {
+  switch (R[0]) {
+  case AS_public:
+  case AS_private:
+  case AS_protected:
+  case AS_none:
+    Field = (AccessSpecifier)R[0];
+    return true;
+  default:
+    return false;
+  }
+}
+
+bool decodeRecord(Record R, TagTypeKind &Field, llvm::StringRef Blob) {
+  switch (R[0]) {
+  case TTK_Struct:
+  case TTK_Interface:
+  case TTK_Union:
+  case TTK_Class:
+  case TTK_Enum:
+    Field = (TagTypeKind)R[0];
+    return true;
+  default:
+    return false;
+  }
+}
+
+bool decodeRecord(Record R, llvm::Optional<Location> &Field,
+                  llvm::StringRef Blob) {
+  if (R[0] > INT_MAX)
+    return false;
+  Field.emplace((int)R[0], Blob);
+  return true;
+}
+
+bool decodeRecord(Record R, InfoType &Field, llvm::StringRef Blob) {
+  switch (auto IT = static_cast<InfoType>(R[0])) {
+  case InfoType::IT_namespace:
+  case InfoType::IT_record:
+  case InfoType::IT_function:
+  case InfoType::IT_default:
+  case InfoType::IT_enum:
+    Field = IT;
+    return true;
+  }
+  return false;
+}
+
+bool decodeRecord(Record R, FieldId &Field, llvm::StringRef Blob) {
+  switch (auto F = static_cast<FieldId>(R[0])) {
+  case FieldId::F_namespace:
+  case FieldId::F_parent:
+  case FieldId::F_vparent:
+  case FieldId::F_type:
+  case FieldId::F_default:
+    Field = F;
+    return true;
+  }
+  return false;
+}
+
+bool decodeRecord(Record R, llvm::SmallVectorImpl<llvm::SmallString<16>> &Field,
+                  llvm::StringRef Blob) {
+  Field.push_back(Blob);
+  return true;
+}
+
+bool decodeRecord(Record R, llvm::SmallVectorImpl<Location> &Field,
+                  llvm::StringRef Blob) {
+  if (R[0] > INT_MAX)
+    return false;
+  Field.emplace_back((int)R[0], Blob);
+  return true;
+}
+
+bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
+                 const unsigned VersionNo) {
+  if (ID == VERSION && R[0] == VersionNo)
+    return true;
+  return false;
+}
+
+bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
+                 NamespaceInfo *I) {
+  switch (ID) {
+  case NAMESPACE_USR:
+    return decodeRecord(R, I->USR, Blob);
+  case NAMESPACE_NAME:
+    return decodeRecord(R, I->Name, Blob);
+  default:
+    return false;
+  }
+}
+
+bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob, RecordInfo *I) {
+  switch (ID) {
+  case RECORD_USR:
+    return decodeRecord(R, I->USR, Blob);
+  case RECORD_NAME:
+    return decodeRecord(R, I->Name, Blob);
+  case RECORD_DEFLOCATION:
+    return decodeRecord(R, I->DefLoc, Blob);
+  case RECORD_LOCATION:
+    return decodeRecord(R, I->Loc, Blob);
+  case RECORD_TAG_TYPE:
+    return decodeRecord(R, I->TagType, Blob);
+  default:
+    return false;
+  }
+}
+
+bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob, EnumInfo *I) {
+  switch (ID) {
+  case ENUM_USR:
+    return decodeRecord(R, I->USR, Blob);
+  case ENUM_NAME:
+    return decodeRecord(R, I->Name, Blob);
+  case ENUM_DEFLOCATION:
+    return decodeRecord(R, I->DefLoc, Blob);
+  case ENUM_LOCATION:
+    return decodeRecord(R, I->Loc, Blob);
+  case ENUM_MEMBER:
+    return decodeRecord(R, I->Members, Blob);
+  case ENUM_SCOPED:
+    return decodeRecord(R, I->Scoped, Blob);
+  default:
+    return false;
+  }
+}
+
+bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob, FunctionInfo *I) {
+  switch (ID) {
+  case FUNCTION_USR:
+    return decodeRecord(R, I->USR, Blob);
+  case FUNCTION_NAME:
+    return decodeRecord(R, I->Name, Blob);
+  case FUNCTION_DEFLOCATION:
+    return decodeRecord(R, I->DefLoc, Blob);
+  case FUNCTION_LOCATION:
+    return decodeRecord(R, I->Loc, Blob);
+  case FUNCTION_ACCESS:
+    return decodeRecord(R, I->Access, Blob);
+  case FUNCTION_IS_METHOD:
+    return decodeRecord(R, I->IsMethod, Blob);
+  default:
+    return false;
+  }
+}
+
+bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob, TypeInfo *I) {
+  return true;
+}
+
+bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
+                 FieldTypeInfo *I) {
+  switch (ID) {
+  case FIELD_TYPE_NAME:
+    return decodeRecord(R, I->Name, Blob);
+  default:
+    return false;
+  }
+}
+
+bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
+                 MemberTypeInfo *I) {
+  switch (ID) {
+  case MEMBER_TYPE_NAME:
+    return decodeRecord(R, I->Name, Blob);
+  case MEMBER_TYPE_ACCESS:
+    return decodeRecord(R, I->Access, Blob);
+  default:
+    return false;
+  }
+}
+
+bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob, CommentInfo *I) {
+  switch (ID) {
+  case COMMENT_KIND:
+    return decodeRecord(R, I->Kind, Blob);
+  case COMMENT_TEXT:
+    return decodeRecord(R, I->Text, Blob);
+  case COMMENT_NAME:
+    return decodeRecord(R, I->Name, Blob);
+  case COMMENT_DIRECTION:
+    return decodeRecord(R, I->Direction, Blob);
+  case COMMENT_PARAMNAME:
+    return decodeRecord(R, I->ParamName, Blob);
+  case COMMENT_CLOSENAME:
+    return decodeRecord(R, I->CloseName, Blob);
+  case COMMENT_ATTRKEY:
+    return decodeRecord(R, I->AttrKeys, Blob);
+  case COMMENT_ATTRVAL:
+    return decodeRecord(R, I->AttrValues, Blob);
+  case COMMENT_ARG:
+    return decodeRecord(R, I->Args, Blob);
+  case COMMENT_SELFCLOSING:
+    return decodeRecord(R, I->SelfClosing, Blob);
+  case COMMENT_EXPLICIT:
+    return decodeRecord(R, I->Explicit, Blob);
+  default:
+    return false;
+  }
+}
+
+bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob, Reference *I,
+                 FieldId &F) {
+  switch (ID) {
+  case REFERENCE_USR:
+    return decodeRecord(R, I->USR, Blob);
+  case REFERENCE_NAME:
+    return decodeRecord(R, I->Name, Blob);
+  case REFERENCE_TYPE:
+    return decodeRecord(R, I->RefType, Blob);
+  case REFERENCE_FIELD:
+    return decodeRecord(R, F, Blob);
+  default:
+    return false;
+  }
+}
+
+template <typename T> CommentInfo *getCommentInfo(T I) {
+  llvm::errs() << "Cannot have comment subblock.\n";
+  exit(1);
+}
+
+template <> CommentInfo *getCommentInfo(FunctionInfo *I) {
+  I->Description.emplace_back();
+  return &I->Description.back();
+}
+
+template <> CommentInfo *getCommentInfo(NamespaceInfo *I) {
+  I->Description.emplace_back();
+  return &I->Description.back();
+}
+
+template <> CommentInfo *getCommentInfo(RecordInfo *I) {
+  I->Description.emplace_back();
+  return &I->Description.back();
+}
+
+template <> CommentInfo *getCommentInfo(EnumInfo *I) {
+  I->Description.emplace_back();
+  return &I->Description.back();
+}
+
+template <> CommentInfo *getCommentInfo(CommentInfo *I) {
+  I->Children.emplace_back(llvm::make_unique<CommentInfo>());
+  return I->Children.back().get();
+}
+
+template <> CommentInfo *getCommentInfo(std::unique_ptr<CommentInfo> &I) {
+  return getCommentInfo(I.get());
+}
+
+template <typename T, typename TTypeInfo>
+void addTypeInfo(T I, TTypeInfo &&TI) {
+  llvm::errs() << "Invalid type for info.\n";
+  exit(1);
+}
+
+template <> void addTypeInfo(RecordInfo *I, MemberTypeInfo &&T) {
+  I->Members.emplace_back(std::move(T));
+}
+
+template <> void addTypeInfo(FunctionInfo *I, TypeInfo &&T) {
+  I->ReturnType = std::move(T);
+}
+
+template <> void addTypeInfo(FunctionInfo *I, FieldTypeInfo &&T) {
+  I->Params.emplace_back(std::move(T));
+}
+
+template <typename T> void addReference(T I, Reference &&R, FieldId F) {
+  llvm::errs() << "Invalid field type for info.\n";
+  exit(1);
+}
+
+template <> void addReference(TypeInfo *I, Reference &&R, FieldId F) {
+  switch (F) {
+  case FieldId::F_type:
+    I->Type = std::move(R);
+    break;
+  default:
+    llvm::errs() << "Invalid field type for info.\n";
+    exit(1);
+  }
+}
+
+template <> void addReference(FieldTypeInfo *I, Reference &&R, FieldId F) {
+  switch (F) {
+  case FieldId::F_type:
+    I->Type = std::move(R);
+    break;
+  default:
+    llvm::errs() << "Invalid field type for info.\n";
+    exit(1);
+  }
+}
+
+template <> void addReference(MemberTypeInfo *I, Reference &&R, FieldId F) {
+  switch (F) {
+  case FieldId::F_type:
+    I->Type = std::move(R);
+    break;
+  default:
+    llvm::errs() << "Invalid field type for info.\n";
+    exit(1);
+  }
+}
+
+template <> void addReference(EnumInfo *I, Reference &&R, FieldId F) {
+  switch (F) {
+  case FieldId::F_namespace:
+    I->Namespace.emplace_back(std::move(R));
+    break;
+  default:
+    llvm::errs() << "Invalid field type for info.\n";
+    exit(1);
+  }
+}
+
+template <> void addReference(NamespaceInfo *I, Reference &&R, FieldId F) {
+  switch (F) {
+  case FieldId::F_namespace:
+    I->Namespace.emplace_back(std::move(R));
+    break;
+  default:
+    llvm::errs() << "Invalid field type for info.\n";
+    exit(1);
+  }
+}
+
+template <> void addReference(FunctionInfo *I, Reference &&R, FieldId F) {
+  switch (F) {
+  case FieldId::F_namespace:
+    I->Namespace.emplace_back(std::move(R));
+    break;
+  case FieldId::F_parent:
+    I->Parent = std::move(R);
+    break;
+  default:
+    llvm::errs() << "Invalid field type for info.\n";
+    exit(1);
+  }
+}
+
+template <> void addReference(RecordInfo *I, Reference &&R, FieldId F) {
+  switch (F) {
+  case FieldId::F_namespace:
+    I->Namespace.emplace_back(std::move(R));
+    break;
+  case FieldId::F_parent:
+    I->Parents.emplace_back(std::move(R));
+    break;
+  case FieldId::F_vparent:
+    I->VirtualParents.emplace_back(std::move(R));
+    break;
+  default:
+    llvm::errs() << "Invalid field type for info.\n";
+    exit(1);
+  }
+}
+
+// Read records from bitcode into a given info.
+template <typename T> bool ClangDocBitcodeReader::readRecord(unsigned ID, T I) {
+  Record R;
+  llvm::StringRef Blob;
+  unsigned RecID = Stream.readRecord(ID, R, &Blob);
+  return parseRecord(R, RecID, Blob, I);
+}
+
+template <> bool ClangDocBitcodeReader::readRecord(unsigned ID, Reference *I) {
+  Record R;
+  llvm::StringRef Blob;
+  unsigned RecID = Stream.readRecord(ID, R, &Blob);
+  return parseRecord(R, RecID, Blob, I, CurrentReferenceField);
+}
+
+// Read a block of records into a single info.
+template <typename T> bool ClangDocBitcodeReader::readBlock(unsigned ID, T I) {
+  if (Stream.EnterSubBlock(ID))
+    return false;
+
+  while (true) {
+    unsigned BlockOrCode = 0;
+    Cursor Res = skipUntilRecordOrBlock(BlockOrCode);
+
+    switch (Res) {
+    case Cursor::BadBlock:
+      return false;
+    case Cursor::BlockEnd:
+      return true;
+    case Cursor::BlockBegin:
+      if (readSubBlock(BlockOrCode, I))
+        continue;
+      if (!Stream.SkipBlock())
+        return false;
+      continue;
+    case Cursor::Record:
+      break;
+    }
+    if (!readRecord(BlockOrCode, I))
+      return false;
+  }
+}
+
+template <typename T>
+bool ClangDocBitcodeReader::readSubBlock(unsigned ID, T I) {
+  switch (ID) {
+  // Blocks can only have Comment, Reference, or TypeInfo subblocks
+  case BI_COMMENT_BLOCK_ID:
+    if (readBlock(ID, getCommentInfo(I)))
+      return true;
+    return false;
+  case BI_TYPE_BLOCK_ID: {
+    TypeInfo TI;
+    if (readBlock(ID, &TI)) {
+      addTypeInfo(I, std::move(TI));
+      return true;
+    }
+    return false;
+  }
+  case BI_FIELD_TYPE_BLOCK_ID: {
+    FieldTypeInfo TI;
+    if (readBlock(ID, &TI)) {
+      addTypeInfo(I, std::move(TI));
+      return true;
+    }
+    return false;
+  }
+  case BI_MEMBER_TYPE_BLOCK_ID: {
+    MemberTypeInfo TI;
+    if (readBlock(ID, &TI)) {
+      addTypeInfo(I, std::move(TI));
+      return true;
+    }
+    return false;
+  }
+  case BI_REFERENCE_BLOCK_ID: {
+    Reference R;
+    if (readBlock(ID, &R)) {
+      addReference(I, std::move(R), CurrentReferenceField);
+      return true;
+    }
+    return false;
+  }
+  default:
+    llvm::errs() << "Invalid subblock type.\n";
+    return false;
+  }
+}
+
+ClangDocBitcodeReader::Cursor
+ClangDocBitcodeReader::skipUntilRecordOrBlock(unsigned &BlockOrRecordID) {
+  BlockOrRecordID = 0;
+
+  while (!Stream.AtEndOfStream()) {
+    unsigned Code = Stream.ReadCode();
+
+    switch ((llvm::bitc::FixedAbbrevIDs)Code) {
+    case llvm::bitc::ENTER_SUBBLOCK:
+      BlockOrRecordID = Stream.ReadSubBlockID();
+      return Cursor::BlockBegin;
+    case llvm::bitc::END_BLOCK:
+      if (Stream.ReadBlockEnd())
+        return Cursor::BadBlock;
+      return Cursor::BlockEnd;
+    case llvm::bitc::DEFINE_ABBREV:
+      Stream.ReadAbbrevRecord();
+      continue;
+    case llvm::bitc::UNABBREV_RECORD:
+      return Cursor::BadBlock;
+    default:
+      BlockOrRecordID = Code;
+      return Cursor::Record;
+    }
+  }
+  llvm_unreachable("Premature stream end.");
+}
+
+bool ClangDocBitcodeReader::validateStream() {
+  if (Stream.AtEndOfStream())
+    return false;
+
+  // Sniff for the signature.
+  if (Stream.Read(8) != BitCodeConstants::Signature[0] ||
+      Stream.Read(8) != BitCodeConstants::Signature[1] ||
+      Stream.Read(8) != BitCodeConstants::Signature[2] ||
+      Stream.Read(8) != BitCodeConstants::Signature[3])
+    return false;
+  return true;
+}
+
+bool ClangDocBitcodeReader::readBlockInfoBlock() {
+  BlockInfo = Stream.ReadBlockInfoBlock();
+  if (!BlockInfo)
+    return false;
+  Stream.setBlockInfo(&*BlockInfo);
+  return true;
+}
+
+template <typename T>
+std::unique_ptr<Info> ClangDocBitcodeReader::createInfo(unsigned ID) {
+  std::unique_ptr<Info> I = llvm::make_unique<T>();
+  if (readBlock(ID, static_cast<T *>(I.get())))
+    return I;
+  llvm::errs() << "Error reading from block.\n";
+  return nullptr;
+}
+
+std::unique_ptr<Info> ClangDocBitcodeReader::readBlockToInfo(unsigned ID) {
+  switch (ID) {
+  case BI_NAMESPACE_BLOCK_ID:
+    return createInfo<NamespaceInfo>(ID);
+  case BI_RECORD_BLOCK_ID:
+    return createInfo<RecordInfo>(ID);
+  case BI_ENUM_BLOCK_ID:
+    return createInfo<EnumInfo>(ID);
+  case BI_FUNCTION_BLOCK_ID:
+    return createInfo<FunctionInfo>(ID);
+  default:
+    llvm::errs() << "Error reading from block.\n";
+    return nullptr;
+  }
+}
+
+// Entry point
+std::vector<std::unique_ptr<Info>> ClangDocBitcodeReader::readBitcode() {
+  std::vector<std::unique_ptr<Info>> Infos;
+  if (!validateStream())
+    return Infos;
+
+  // Read the top level blocks.
+  while (!Stream.AtEndOfStream()) {
+    unsigned Code = Stream.ReadCode();
+    if (Code != llvm::bitc::ENTER_SUBBLOCK)
+      return Infos;
+
+    unsigned ID = Stream.ReadSubBlockID();
+    switch (ID) {
+    // NamedType and Comment blocks should not appear at the top level
+    case BI_TYPE_BLOCK_ID:
+    case BI_FIELD_TYPE_BLOCK_ID:
+    case BI_MEMBER_TYPE_BLOCK_ID:
+    case BI_COMMENT_BLOCK_ID:
+    case BI_REFERENCE_BLOCK_ID:
+      llvm::errs() << "Invalid top level block.\n";
+      return Infos;
+    case BI_NAMESPACE_BLOCK_ID:
+    case BI_RECORD_BLOCK_ID:
+    case BI_ENUM_BLOCK_ID:
+    case BI_FUNCTION_BLOCK_ID:
+      if (std::unique_ptr<Info> I = readBlockToInfo(ID)) {
+        Infos.emplace_back(std::move(I));
+      }
+      return Infos;
+    case BI_VERSION_BLOCK_ID:
+      if (readBlock(ID, VersionNumber))
+        continue;
+      return Infos;
+    case llvm::bitc::BLOCKINFO_BLOCK_ID:
+      if (readBlockInfoBlock())
+        continue;
+      return Infos;
+    default:
+      if (!Stream.SkipBlock())
+        continue;
+    }
+  }
+  return Infos;
+}
+
+} // namespace doc
+} // namespace clang

clang-tools-extra/trunk/clang-doc/BitcodeWriter.h

 namespace doc {
 
 // Current version number of clang-doc bitcode.
 // Should be bumped when removing or changing BlockIds, RecordIds, or
 // BitCodeConstants, though they can be added without breaking it.
 static const unsigned VersionNumber = 2;
 
 struct BitCodeConstants {
-  static constexpr unsigned RecordSize = 16U;
+  static constexpr unsigned RecordSize = 32U;
   static constexpr unsigned SignatureBitSize = 8U;
   static constexpr unsigned SubblockIDSize = 4U;
   static constexpr unsigned BoolSize = 1U;
   static constexpr unsigned IntSize = 16U;
   static constexpr unsigned StringLengthSize = 16U;
   static constexpr unsigned FilenameLengthSize = 16U;
   static constexpr unsigned LineNumberSize = 16U;
   static constexpr unsigned ReferenceTypeSize = 8U;
   static constexpr unsigned USRLengthSize = 6U;
   static constexpr unsigned USRBitLengthSize = 8U;
+  static constexpr char Signature[4] = {'D', 'O', 'C', 'S'};
+  static constexpr int USRHashSize = 20;
 };
 
 // New Ids need to be added to both the enum here and the relevant IdNameMap in
 // the implementation file.
 enum BlockId {
   BI_VERSION_BLOCK_ID = llvm::bitc::FIRST_APPLICATION_BLOCKID,
   BI_NAMESPACE_BLOCK_ID,
   BI_ENUM_BLOCK_ID,

 };
 
 static constexpr unsigned BlockIdCount = BI_LAST - BI_FIRST;
 static constexpr unsigned RecordIdCount = RI_LAST - RI_FIRST;
 
 #undef INFORECORDS
 
 // Identifiers for differentiating between subblocks
-enum class FieldId { F_namespace = 1, F_parent, F_vparent, F_type };
+enum class FieldId { F_default, F_namespace, F_parent, F_vparent, F_type };
 
 class ClangDocBitcodeWriter {
 public:
   ClangDocBitcodeWriter(llvm::BitstreamWriter &Stream) : Stream(Stream) {
     emitHeader();
     emitBlockInfoBlock();
     emitVersionBlock();
   }
 
-#ifndef NDEBUG // Don't want explicit dtor unless needed.
-  ~ClangDocBitcodeWriter() {
-    // Check that the static size is large-enough.
-    assert(Record.capacity() > BitCodeConstants::RecordSize);
-  }
-#endif
+  // Write a specific info to a bitcode stream.
+  bool dispatchInfoForWrite(Info *I);
 
   // Block emission of different info types.
   void emitBlock(const NamespaceInfo &I);
   void emitBlock(const RecordInfo &I);
   void emitBlock(const FunctionInfo &I);
   void emitBlock(const EnumInfo &I);
   void emitBlock(const TypeInfo &B);
   void emitBlock(const FieldTypeInfo &B);

clang-tools-extra/trunk/clang-doc/BitcodeWriter.cpp

RecordsByBlock{
          {FUNCTION_USR, FUNCTION_NAME, FUNCTION_DEFLOCATION, FUNCTION_LOCATION,
           FUNCTION_ACCESS, FUNCTION_IS_METHOD}},
         // Reference Block
         {BI_REFERENCE_BLOCK_ID,
          {REFERENCE_USR, REFERENCE_NAME, REFERENCE_TYPE, REFERENCE_FIELD}}};
 
 // AbbreviationMap
 
+constexpr char BitCodeConstants::Signature[];
+
 void ClangDocBitcodeWriter::AbbreviationMap::add(RecordId RID,
                                                  unsigned AbbrevID) {
   assert(RecordIdNameMap[RID] && "Unknown RecordId.");
   assert(Abbrevs.find(RID) == Abbrevs.end() && "Abbreviation already added.");
   Abbrevs[RID] = AbbrevID;
 }
 
 unsigned ClangDocBitcodeWriter::AbbreviationMap::get(RecordId RID) const {
   assert(RecordIdNameMap[RID] && "Unknown RecordId.");
   assert(Abbrevs.find(RID) != Abbrevs.end() && "Unknown abbreviation.");
   return Abbrevs.lookup(RID);
 }
 
 // Validation and Overview Blocks
 
 /// \brief Emits the magic number header to check that its the right format,
 /// in this case, 'DOCS'.
 void ClangDocBitcodeWriter::emitHeader() {
-  for (char C : llvm::StringRef("DOCS"))
+  for (char C : BitCodeConstants::Signature)
     Stream.Emit((unsigned)C, BitCodeConstants::SignatureBitSize);
 }
 
 void ClangDocBitcodeWriter::emitVersionBlock() {
   StreamSubBlockGuard Block(Stream, BI_VERSION_BLOCK_ID);
   emitRecord(VersionNumber, VERSION);
 }
 
void ClangDocBitcodeWriter::emitBlock(const CommentInfo &I) {
   for (const auto &A : I.AttrValues)
     emitRecord(A, COMMENT_ATTRVAL);
   for (const auto &A : I.Args)
     emitRecord(A, COMMENT_ARG);
   for (const auto &C : I.Children)
     emitBlock(*C);
 }
 
-#define EMITINFO(X)                                                            \
-  emitRecord(I.USR, X##_USR);                                                  \
-  emitRecord(I.Name, X##_NAME);                                                \
-  for (const auto &N : I.Namespace)                                            \
-    emitBlock(N, FieldId::F_namespace);                                        \
-  for (const auto &CI : I.Description)                                         \
-    emitBlock(CI);
-
 void ClangDocBitcodeWriter::emitBlock(const NamespaceInfo &I) {
   StreamSubBlockGuard Block(Stream, BI_NAMESPACE_BLOCK_ID);
-  EMITINFO(NAMESPACE)
+  emitRecord(I.USR, NAMESPACE_USR);
+  emitRecord(I.Name, NAMESPACE_NAME);
+  for (const auto &N : I.Namespace)
+    emitBlock(N, FieldId::F_namespace);
+  for (const auto &CI : I.Description)
+    emitBlock(CI);
 }
 
 void ClangDocBitcodeWriter::emitBlock(const EnumInfo &I) {
   StreamSubBlockGuard Block(Stream, BI_ENUM_BLOCK_ID);
-  EMITINFO(ENUM)
+  emitRecord(I.USR, ENUM_USR);
+  emitRecord(I.Name, ENUM_NAME);
+  for (const auto &N : I.Namespace)
+    emitBlock(N, FieldId::F_namespace);
+  for (const auto &CI : I.Description)
+    emitBlock(CI);
   if (I.DefLoc)
     emitRecord(I.DefLoc.getValue(), ENUM_DEFLOCATION);
   for (const auto &L : I.Loc)
     emitRecord(L, ENUM_LOCATION);
   emitRecord(I.Scoped, ENUM_SCOPED);
   for (const auto &N : I.Members)
     emitRecord(N, ENUM_MEMBER);
 }
 
 void ClangDocBitcodeWriter::emitBlock(const RecordInfo &I) {
   StreamSubBlockGuard Block(Stream, BI_RECORD_BLOCK_ID);
-  EMITINFO(RECORD)
+  emitRecord(I.USR, RECORD_USR);
+  emitRecord(I.Name, RECORD_NAME);
+  for (const auto &N : I.Namespace)
+    emitBlock(N, FieldId::F_namespace);
+  for (const auto &CI : I.Description)
+    emitBlock(CI);
   if (I.DefLoc)
     emitRecord(I.DefLoc.getValue(), RECORD_DEFLOCATION);
   for (const auto &L : I.Loc)
     emitRecord(L, RECORD_LOCATION);
   emitRecord(I.TagType, RECORD_TAG_TYPE);
   for (const auto &N : I.Members)
     emitBlock(N);
   for (const auto &P : I.Parents)
     emitBlock(P, FieldId::F_parent);
   for (const auto &P : I.VirtualParents)
     emitBlock(P, FieldId::F_vparent);
 }
 
 void ClangDocBitcodeWriter::emitBlock(const FunctionInfo &I) {
   StreamSubBlockGuard Block(Stream, BI_FUNCTION_BLOCK_ID);
-  EMITINFO(FUNCTION)
+  emitRecord(I.USR, FUNCTION_USR);
+  emitRecord(I.Name, FUNCTION_NAME);
+  for (const auto &N : I.Namespace)
+    emitBlock(N, FieldId::F_namespace);
+  for (const auto &CI : I.Description)
+    emitBlock(CI);
   emitRecord(I.IsMethod, FUNCTION_IS_METHOD);
   if (I.DefLoc)
     emitRecord(I.DefLoc.getValue(), FUNCTION_DEFLOCATION);
   for (const auto &L : I.Loc)
     emitRecord(L, FUNCTION_LOCATION);
   emitBlock(I.Parent, FieldId::F_parent);
   emitBlock(I.ReturnType);
   for (const auto &N : I.Params)
     emitBlock(N);
 }
 
-#undef EMITINFO
+bool ClangDocBitcodeWriter::dispatchInfoForWrite(Info *I) {
+  switch (I->IT) {
+  case InfoType::IT_namespace:
+    emitBlock(*static_cast<clang::doc::NamespaceInfo *>(I));
+    break;
+  case InfoType::IT_record:
+    emitBlock(*static_cast<clang::doc::RecordInfo *>(I));
+    break;
+  case InfoType::IT_enum:
+    emitBlock(*static_cast<clang::doc::EnumInfo *>(I));
+    break;
+  case InfoType::IT_function:
+    emitBlock(*static_cast<clang::doc::FunctionInfo *>(I));
+    break;
+  default:
+    llvm::errs() << "Unexpected info, unable to write.\n";
+    return true;
+  }
+  return false;
+}
 
 } // namespace doc
 } // namespace clang

clang-tools-extra/trunk/clang-doc/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   support
   )
 
 add_clang_library(clangDoc
+  BitcodeReader.cpp
   BitcodeWriter.cpp
   ClangDoc.cpp
   Mapper.cpp
+  Representation.cpp
   Serialize.cpp
 
   LINK_LIBS
   clangAnalysis
   clangAST
   clangASTMatchers
   clangBasic
   clangFrontend
   clangIndex
   clangLex
   clangTooling
   clangToolingCore
   )
 
 add_subdirectory(tool)

clang-tools-extra/trunk/clang-doc/Representation.h

-///===-- Representation.h - ClangDoc Represenation --------------*- C++ -*-===//
+///===-- Representation.h - ClangDoc Representation -------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include <array>
 #include <string>
 
 namespace clang {
 namespace doc {
 
+// SHA1'd hash of a USR.
 using SymbolID = std::array<uint8_t, 20>;
 
 struct Info;
 enum class InfoType {
   IT_default,
   IT_namespace,
   IT_record,
   IT_function,
   IT_enum
 };
 
 // A representation of a parsed comment.
 struct CommentInfo {
   CommentInfo() = default;
-  CommentInfo(CommentInfo &&Other) : Children(std::move(Other.Children)) {}
+  CommentInfo(CommentInfo &Other) = delete;
+  CommentInfo(CommentInfo &&Other) = default;
 
   SmallString<16> Kind; // Kind of comment (TextComment, InlineCommandComment,
                         // HTMLStartTagComment, HTMLEndTagComment,
                         // BlockCommandComment, ParamCommandComment,
                         // TParamCommandComment, VerbatimBlockComment,
                         // VerbatimBlockLineComment, VerbatimLineComment).
   SmallString<64> Text; // Text of the comment.
   SmallString<16> Name; // Name of the comment (for Verbatim and HTML).
struct Location {
 
   int LineNumber;           // Line number of this Location.
   SmallString<32> Filename; // File for this Location.
 };
 
 /// A base struct for Infos.
 struct Info {
   Info() = default;
-  Info(Info &&Other) : Description(std::move(Other.Description)) {}
-  virtual ~Info() = default;
-
-  SymbolID USR; // Unique identifier for the decl described by this Info.
-  SmallString<16> Name; // Unqualified name of the decl.
+  Info(InfoType IT) : IT(IT) {}
+  Info(const Info &Other) = delete;
+  Info(Info &&Other) = default;
+
+  SymbolID USR =
+      SymbolID(); // Unique identifier for the decl described by this Info.
+  const InfoType IT = InfoType::IT_default; // InfoType of this particular Info.
+  SmallString<16> Name;                     // Unqualified name of the decl.
   llvm::SmallVector<Reference, 4>
       Namespace; // List of parent namespaces for this decl.
   std::vector<CommentInfo> Description; // Comment description of this decl.
+
+  void mergeBase(Info &&I);
+  bool mergeable(const Info &Other);
 };
 
 // Info for namespaces.
-struct NamespaceInfo : public Info {};
+struct NamespaceInfo : public Info {
+  NamespaceInfo() : Info(InfoType::IT_namespace) {}
+
+  void merge(NamespaceInfo &&I);
+};
 
 // Info for symbols.
 struct SymbolInfo : public Info {
+  SymbolInfo(InfoType IT) : Info(IT) {}
+
+  void merge(SymbolInfo &&I);
+
   llvm::Optional<Location> DefLoc;    // Location where this decl is defined.
   llvm::SmallVector<Location, 2> Loc; // Locations where this decl is declared.
 };
 
 // TODO: Expand to allow for documenting templating and default args.
 // Info for functions.
 struct FunctionInfo : public SymbolInfo {
+  FunctionInfo() : SymbolInfo(InfoType::IT_function) {}
+
+  void merge(FunctionInfo &&I);
+
   bool IsMethod = false; // Indicates whether this function is a class method.
   Reference Parent;      // Reference to the parent class decl for this method.
   TypeInfo ReturnType;   // Info about the return type of this function.
   llvm::SmallVector<FieldTypeInfo, 4> Params;        // List of parameters.
   AccessSpecifier Access = AccessSpecifier::AS_none; // Access level for this
                                                      // method (public, private,
                                                      // protected, none).
 };
 
 // TODO: Expand to allow for documenting templating, inheritance access,
 // friend classes
 // Info for types.
 struct RecordInfo : public SymbolInfo {
-  TagTypeKind TagType = TagTypeKind::TTK_Struct; // Type of this record (struct,
-                                                 // class, union, interface).
+  RecordInfo() : SymbolInfo(InfoType::IT_record) {}
+
+  void merge(RecordInfo &&I);
+
+  TagTypeKind TagType = TagTypeKind::TTK_Struct; // Type of this record
+                                                 // (struct, class, union,
+                                                 // interface).
   llvm::SmallVector<MemberTypeInfo, 4>
       Members;                             // List of info about record members.
-  llvm::SmallVector<Reference, 4> Parents; // List of base/parent records (does
-                                           // not include virtual parents).
+  llvm::SmallVector<Reference, 4> Parents; // List of base/parent records
+                                           // (does not include virtual
+                                           // parents).
   llvm::SmallVector<Reference, 4>
       VirtualParents; // List of virtual base/parent records.
 };
 
 // TODO: Expand to allow for documenting templating.
 // Info for types.
 struct EnumInfo : public SymbolInfo {
+  EnumInfo() : SymbolInfo(InfoType::IT_enum) {}
+
+  void merge(EnumInfo &&I);
+
   bool Scoped =
       false; // Indicates whether this enum is scoped (e.g. enum class).
   llvm::SmallVector<SmallString<16>, 4> Members; // List of enum members.
 };
 
 // TODO: Add functionality to include separate markdown pages.
 
+// A standalone function to call to merge a vector of infos into one.
+// This assumes that all infos in the vector are of the same type, and will fail
+// if they are different.
+llvm::Expected<std::unique_ptr<Info>>
+mergeInfos(std::vector<std::unique_ptr<Info>> &Values);
+
 } // namespace doc
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_REPRESENTATION_H

clang-tools-extra/trunk/clang-doc/Representation.cpp

+///===-- Representation.cpp - ClangDoc Representation -----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the merging of different types of infos. The data in the
+// calling Info is preserved during a merge unless that field is empty or
+// default. In that case, the data from the parameter Info is used to replace
+// the empty or default data.
+//
+// For most fields, the first decl seen provides the data. Exceptions to this
+// include the location and description fields, which are collections of data on
+// all decls related to a given definition. All other fields are ignored in new
+// decls unless the first seen decl didn't, for whatever reason, incorporate
+// data on that field (e.g. a forward declared class wouldn't have information
+// on members on the forward declaration, but would have the class name).
+//
+//===----------------------------------------------------------------------===//
+#include "Representation.h"
+#include "llvm/Support/Error.h"
+
+namespace clang {
+namespace doc {
+
+static const SymbolID EmptySID = SymbolID();
+
+template <typename T>
+std::unique_ptr<Info> reduce(std::vector<std::unique_ptr<Info>> &Values) {
+  std::unique_ptr<Info> Merged = llvm::make_unique<T>();
+  T *Tmp = static_cast<T *>(Merged.get());
+  for (auto &I : Values)
+    Tmp->merge(std::move(*static_cast<T *>(I.get())));
+  return Merged;
+}
+
+// Dispatch function.
+llvm::Expected<std::unique_ptr<Info>>
+mergeInfos(std::vector<std::unique_ptr<Info>> &Values) {
+  if (Values.empty())
+    return llvm::make_error<llvm::StringError>("No info values to merge.\n",
+                                             llvm::inconvertibleErrorCode());
+
+  switch (Values[0]->IT) {
+  case InfoType::IT_namespace:
+    return reduce<NamespaceInfo>(Values);
+  case InfoType::IT_record:
+    return reduce<RecordInfo>(Values);
+  case InfoType::IT_enum:
+    return reduce<EnumInfo>(Values);
+  case InfoType::IT_function:
+    return reduce<FunctionInfo>(Values);
+  default:
+    return llvm::make_error<llvm::StringError>("Unexpected info type.\n",
+                                               llvm::inconvertibleErrorCode());
+  }
+}
+
+void Info::mergeBase(Info &&Other) {
+  assert(mergeable(Other));
+  if (USR == EmptySID)
+    USR = Other.USR;
+  if (Name == "")
+    Name = Other.Name;
+  if (Namespace.empty())
+    Namespace = std::move(Other.Namespace);
+  // Unconditionally extend the description, since each decl may have a comment.
+  std::move(Other.Description.begin(), Other.Description.end(),
+            std::back_inserter(Description));
+}
+
+bool Info::mergeable(const Info &Other) {
+  return IT == Other.IT && (USR == EmptySID || USR == Other.USR);
+}
+
+void SymbolInfo::merge(SymbolInfo &&Other) {
+  assert(mergeable(Other));
+  if (!DefLoc)
+    DefLoc = std::move(Other.DefLoc);
+  // Unconditionally extend the list of locations, since we want all of them.
+  std::move(Other.Loc.begin(), Other.Loc.end(), std::back_inserter(Loc));
+  mergeBase(std::move(Other));
+}
+
+void NamespaceInfo::merge(NamespaceInfo &&Other) {
+  assert(mergeable(Other));
+  mergeBase(std::move(Other));
+}
+
+void RecordInfo::merge(RecordInfo &&Other) {
+  assert(mergeable(Other));
+  if (!TagType)
+    TagType = Other.TagType;
+  if (Members.empty())
+    Members = std::move(Other.Members);
+  if (Parents.empty())
+    Parents = std::move(Other.Parents);
+  if (VirtualParents.empty())
+    VirtualParents = std::move(Other.VirtualParents);
+  SymbolInfo::merge(std::move(Other));
+}
+
+void EnumInfo::merge(EnumInfo &&Other) {
+  assert(mergeable(Other));
+  if (!Scoped)
+    Scoped = Other.Scoped;
+  if (Members.empty())
+    Members = std::move(Other.Members);
+  SymbolInfo::merge(std::move(Other));
+}
+
+void FunctionInfo::merge(FunctionInfo &&Other) {
+  assert(mergeable(Other));
+  if (!IsMethod)
+    IsMethod = Other.IsMethod;
+  if (!Access)
+    Access = Other.Access;
+  if (ReturnType.Type.USR == EmptySID && ReturnType.Type.Name == "")
+    ReturnType = std::move(Other.ReturnType);
+  if (Parent.USR == EmptySID && Parent.Name == "")
+    Parent = std::move(Other.Parent);
+  if (Params.empty())
+    Params = std::move(Other.Params);
+  SymbolInfo::merge(std::move(Other));
+}
+
+} // namespace doc
+} // namespace clang

clang-tools-extra/trunk/clang-doc/tool/ClangDocMain.cpp

 // information into LLVM bitcode. It then runs a pass over the collected
 // declaration information, reducing by USR. There is an option to dump this
 // intermediate result to bitcode. Finally, it hands the reduced information
 // off to a generator, which does the final parsing from the intermediate
 // representation to the desired output format.
 //
 //===----------------------------------------------------------------------===//
 
+#include "BitcodeReader.h"
+#include "BitcodeWriter.h"
 #include "ClangDoc.h"
+#include "Representation.h"
 #include "clang/AST/AST.h"
 #include "clang/AST/Decl.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchersInternal.h"
 #include "clang/Driver/Options.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Execution.h"
 #include "clang/Tooling/StandaloneExecution.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/APFloat.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 #include <string>
 
 using namespace clang::ast_matchers;
 using namespace clang::tooling;
 using namespace clang;
 
 static llvm::cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
 static llvm::cl::OptionCategory ClangDocCategory("clang-doc options");
 
 static llvm::cl::opt<std::string>
     OutDirectory("output",
                  llvm::cl::desc("Directory for outputting generated files."),
                  llvm::cl::init("docs"), llvm::cl::cat(ClangDocCategory));
 
 static llvm::cl::opt<bool>
     DumpMapperResult("dump-mapper",
                      llvm::cl::desc("Dump mapper results to bitcode file."),
                      llvm::cl::init(false), llvm::cl::cat(ClangDocCategory));
 
+static llvm::cl::opt<bool> DumpIntermediateResult(
+    "dump-intermediate",
+    llvm::cl::desc("Dump intermediate results to bitcode file."),
+    llvm::cl::init(false), llvm::cl::cat(ClangDocCategory));
+
+enum OutputFormatTy {
+  yaml,
+};
+
+static llvm::cl::opt<OutputFormatTy>
+    Format("format", llvm::cl::desc("Format for outputted docs."),
+           llvm::cl::values(clEnumVal(yaml, "Documentation in YAML format.")),
+           llvm::cl::init(yaml), llvm::cl::cat(ClangDocCategory));
+
 static llvm::cl::opt<bool> DoxygenOnly(
     "doxygen",
     llvm::cl::desc("Use only doxygen-style comments to generate docs."),
     llvm::cl::init(false), llvm::cl::cat(ClangDocCategory));
 
+bool CreateDirectory(const Twine &DirName, bool ClearDirectory = false) {
+  std::error_code OK;
+  llvm::SmallString<128> DocsRootPath;
+  if (ClearDirectory) {
+    std::error_code RemoveStatus = llvm::sys::fs::remove_directories(DirName);
+    if (RemoveStatus != OK) {
+      llvm::errs() << "Unable to remove existing documentation directory for "
+                   << DirName << ".\n";
+      return true;
+    }
+  }
+  std::error_code DirectoryStatus = llvm::sys::fs::create_directories(DirName);
+  if (DirectoryStatus != OK) {
+    llvm::errs() << "Unable to create documentation directories.\n";
+    return true;
+  }
+  return false;
+}
+
+bool DumpResultToFile(const Twine &DirName, const Twine &FileName,
+                      StringRef Buffer, bool ClearDirectory = false) {
+  std::error_code OK;
+  llvm::SmallString<128> IRRootPath;
+  llvm::sys::path::native(OutDirectory, IRRootPath);
+  llvm::sys::path::append(IRRootPath, DirName);
+  if (CreateDirectory(IRRootPath, ClearDirectory))
+    return true;
+  llvm::sys::path::append(IRRootPath, FileName);
+  std::error_code OutErrorInfo;
+  llvm::raw_fd_ostream OS(IRRootPath, OutErrorInfo, llvm::sys::fs::F_None);
+  if (OutErrorInfo != OK) {
+    llvm::errs() << "Error opening documentation file.\n";
+    return true;
+  }
+  OS << Buffer;
+  OS.close();
+  return false;
+}
+
 int main(int argc, const char **argv) {
   llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
-  std::error_code OK;
 
   auto Exec = clang::tooling::createExecutorFromCommandLineArgs(
       argc, argv, ClangDocCategory);
 
   if (!Exec) {
     llvm::errs() << toString(Exec.takeError()) << "\n";
     return 1;
   }
 
   ArgumentsAdjuster ArgAdjuster;
   if (!DoxygenOnly)
     ArgAdjuster = combineAdjusters(
         getInsertArgumentAdjuster("-fparse-all-comments",
                                   tooling::ArgumentInsertPosition::END),
         ArgAdjuster);
 
   // Mapping phase
   llvm::outs() << "Mapping decls...\n";
-  auto Err = Exec->get()->execute(doc::newMapperActionFactory(
-                                      Exec->get()->getExecutionContext()),
-                                  ArgAdjuster);
-  if (Err)
+  auto Err = Exec->get()->execute(
+      doc::newMapperActionFactory(Exec->get()->getExecutionContext()),
+  if (Err) {
     llvm::errs() << toString(std::move(Err)) << "\n";
+    return 1;
+  }
 
   if (DumpMapperResult) {
-    Exec->get()->getToolResults()->forEachResult([&](StringRef Key,
-                                                     StringRef Value) {
-      SmallString<128> IRRootPath;
-      llvm::sys::path::native(OutDirectory, IRRootPath);
-      llvm::sys::path::append(IRRootPath, "bc");
-      std::error_code DirectoryStatus =
-          llvm::sys::fs::create_directories(IRRootPath);
-      if (DirectoryStatus != OK) {
-        llvm::errs() << "Unable to create documentation directories.\n";
-        return;
-      }
-      llvm::sys::path::append(IRRootPath, Key + ".bc");
-      std::error_code OutErrorInfo;
-      llvm::raw_fd_ostream OS(IRRootPath, OutErrorInfo, llvm::sys::fs::F_None);
-      if (OutErrorInfo != OK) {
-        llvm::errs() << "Error opening documentation file.\n";
-        return;
-      }
-      OS << Value;
-      OS.close();
-    });
+    bool Err = false;
+    Exec->get()->getToolResults()->forEachResult(
+        [&](StringRef Key, StringRef Value) {
+          Err = DumpResultToFile("bc", Key + ".bc", Value);
+        });
+    if (Err)
+      llvm::errs() << "Error dumping map results.\n";
+    return Err;
+  }
+
+  // Collect values into output by key.
+  llvm::outs() << "Collecting infos...\n";
+  llvm::StringMap<std::vector<std::unique_ptr<doc::Info>>> MapOutput;
+
+  // In ToolResults, the Key is the hashed USR and the value is the
+  // bitcode-encoded representation of the Info object.
+    llvm::BitstreamCursor Stream(Value);
+    doc::ClangDocBitcodeReader Reader(Stream);
+    auto Infos = Reader.readBitcode();
+    for (auto &I : Infos) {
+      auto R =
+          MapOutput.try_emplace(Key, std::vector<std::unique_ptr<doc::Info>>());
+      R.first->second.emplace_back(std::move(I));
+
+  // Reducing phase
+  llvm::outs() << "Reducing " << MapOutput.size() << " infos...\n";
+  llvm::StringMap<std::unique_ptr<doc::Info>> ReduceOutput;
+  for (auto &Group : MapOutput) {
+    auto Reduced = doc::mergeInfos(Group.getValue());
+    if (!Reduced)
+      llvm::errs() << llvm::toString(Reduced.takeError());
+
+    if (DumpIntermediateResult) {
+      SmallString<4096> Buffer;
+      llvm::BitstreamWriter Stream(Buffer);
+      doc::ClangDocBitcodeWriter Writer(Stream);
+      Writer.dispatchInfoForWrite(Reduced.get().get());
+      if (DumpResultToFile("bc", Group.getKey() + ".bc", Buffer)) {
+        llvm::errs() << "Error writing " << Group.getKey() << " to file.\n";
+        continue;
+      }
+    }
+
+    ReduceOutput.insert(
+        std::make_pair(Group.getKey(), std::move(Reduced.get())));
+
+    // FIXME: Add support for emitting different output formats.
   }
 
   return 0;
 }

clang-tools-extra/trunk/test/clang-doc/bc-comment.cpp

+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: echo "" > %t/compile_flags.txt
+// RUN: cp "%s" "%t/test.cpp"
+// RUN: clang-doc --dump-intermediate -doxygen -p %t %t/test.cpp -output=%t/docs
+// RUN: llvm-bcanalyzer %t/docs/bc/7574630614A535710E5A6ABCFFF98BCA2D06A4CA.bc --dump | FileCheck %s
+ 
+/// \brief Brief description.
+///
+/// Extended description that
+/// continues onto the next line.
+/// 
+/// <ul class="test">
+///   <li> Testing.
+/// </ul>
+///
+/// \verbatim
+/// The description continues.
+/// \endverbatim
+/// --
+/// \param [out] I is a parameter.
+/// \param J is a parameter.
+/// \return void
+void F(int I, int J);
+
+/// Bonus comment on definition
+void F(int I, int J) {}
+
+// CHECK: <BLOCKINFO_BLOCK/>
+// CHECK-NEXT: <VersionBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-NEXT: <Version abbrevid=4 op0=2/>
+// CHECK-NEXT: </VersionBlock>
+// CHECK-NEXT: <FunctionBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-NEXT: <USR abbrevid=4 op0=20 op1=117 op2=116 op3=99 op4=6 op5=20 op6=165 op7=53 op8=113 op9=14 op10=90 op11=106 op12=188 op13=255 op14=249 op15=139 op16=202 op17=45 op18=6 op19=164 op20=202/>
+  // CHECK-NEXT: <Name abbrevid=5 op0=1/> blob data = 'F'
+  // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'FullComment'
+    // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Kind abbrevid=4 op0=16/> blob data = 'ParagraphComment'
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+      // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Kind abbrevid=4 op0=19/> blob data = 'BlockCommandComment'
+      // CHECK-NEXT: <Name abbrevid=6 op0=5/> blob data = 'brief'
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=16/> blob data = 'ParagraphComment'
+        // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+          // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+          // CHECK-NEXT: <Text abbrevid=5 op0=19/> blob data = ' Brief description.'
+        // CHECK-NEXT: </CommentBlock>
+      // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Kind abbrevid=4 op0=16/> blob data = 'ParagraphComment'
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+        // CHECK-NEXT: <Text abbrevid=5 op0=26/> blob data = ' Extended description that'
+      // CHECK-NEXT: </CommentBlock>
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+        // CHECK-NEXT: <Text abbrevid=5 op0=30/> blob data = ' continues onto the next line.'
+      // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Kind abbrevid=4 op0=16/> blob data = 'ParagraphComment'
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+      // CHECK-NEXT: </CommentBlock>
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=19/> blob data = 'HTMLStartTagComment'
+        // CHECK-NEXT: <Name abbrevid=6 op0=2/> blob data = 'ul'
+        // CHECK-NEXT: <AttrKey abbrevid=12 op0=5/> blob data = 'class'
+        // CHECK-NEXT: <AttrVal abbrevid=13 op0=4/> blob data = 'test'
+      // CHECK-NEXT: </CommentBlock>
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+      // CHECK-NEXT: </CommentBlock>
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=19/> blob data = 'HTMLStartTagComment'
+        // CHECK-NEXT: <Name abbrevid=6 op0=2/> blob data = 'li'
+      // CHECK-NEXT: </CommentBlock>
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+        // CHECK-NEXT: <Text abbrevid=5 op0=9/> blob data = ' Testing.'
+      // CHECK-NEXT: </CommentBlock>
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+      // CHECK-NEXT: </CommentBlock>
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=17/> blob data = 'HTMLEndTagComment'
+        // CHECK-NEXT: <Name abbrevid=6 op0=2/> blob data = 'ul'
+        // CHECK-NEXT: <SelfClosing abbrevid=10 op0=1/>
+      // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Kind abbrevid=4 op0=16/> blob data = 'ParagraphComment'
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+      // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Kind abbrevid=4 op0=20/> blob data = 'VerbatimBlockComment'
+      // CHECK-NEXT: <Name abbrevid=6 op0=8/> blob data = 'verbatim'
+      // CHECK-NEXT: <CloseName abbrevid=9 op0=11/> blob data = 'endverbatim'
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=24/> blob data = 'VerbatimBlockLineComment'
+        // CHECK-NEXT: <Text abbrevid=5 op0=27/> blob data = ' The description continues.'
+      // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Kind abbrevid=4 op0=16/> blob data = 'ParagraphComment'
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+        // CHECK-NEXT: <Text abbrevid=5 op0=3/> blob data = ' --'
+      // CHECK-NEXT: </CommentBlock>
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+      // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Kind abbrevid=4 op0=19/> blob data = 'ParamCommandComment'
+      // CHECK-NEXT: <Direction abbrevid=7 op0=5/> blob data = '[out]'
+      // CHECK-NEXT: <ParamName abbrevid=8 op0=1/> blob data = 'I'
+      // CHECK-NEXT: <Explicit abbrevid=11 op0=1/>
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=16/> blob data = 'ParagraphComment'
+        // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+          // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+          // CHECK-NEXT: <Text abbrevid=5 op0=16/> blob data = ' is a parameter.'
+        // CHECK-NEXT: </CommentBlock>
+        // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+          // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+        // CHECK-NEXT: </CommentBlock>
+      // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Kind abbrevid=4 op0=19/> blob data = 'ParamCommandComment'
+      // CHECK-NEXT: <Direction abbrevid=7 op0=4/> blob data = '[in]'
+      // CHECK-NEXT: <ParamName abbrevid=8 op0=1/> blob data = 'J'
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=16/> blob data = 'ParagraphComment'
+        // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+          // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+          // CHECK-NEXT: <Text abbrevid=5 op0=16/> blob data = ' is a parameter.'
+        // CHECK-NEXT: </CommentBlock>
+        // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+          // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+        // CHECK-NEXT: </CommentBlock>
+      // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Kind abbrevid=4 op0=19/> blob data = 'BlockCommandComment'
+      // CHECK-NEXT: <Name abbrevid=6 op0=6/> blob data = 'return'
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=16/> blob data = 'ParagraphComment'
+        // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+          // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+          // CHECK-NEXT: <Text abbrevid=5 op0=5/> blob data = ' void'
+        // CHECK-NEXT: </CommentBlock>
+      // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: </CommentBlock>
+  // CHECK-NEXT: </CommentBlock>
+  // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'FullComment'
+    // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Kind abbrevid=4 op0=16/> blob data = 'ParagraphComment'
+      // CHECK-NEXT: <CommentBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+        // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
+        // CHECK-NEXT: <Text abbrevid=5 op0=28/> blob data = ' Bonus comment on definition'
+      // CHECK-NEXT: </CommentBlock>
+    // CHECK-NEXT: </CommentBlock>
+  // CHECK-NEXT: </CommentBlock>
+  // CHECK-NEXT: <DefLocation abbrevid=6 op0=27 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-NEXT: <Location abbrevid=7 op0=24 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-NEXT: <TypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Name abbrevid=5 op0=4/> blob data = 'void'
+      // CHECK-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-NEXT: </ReferenceBlock>
+  // CHECK-NEXT: </TypeBlock>
+  // CHECK-NEXT: <FieldTypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-NEXT: </ReferenceBlock>
+    // CHECK-NEXT: <Name abbrevid=4 op0=1/> blob data = 'I'
+  // CHECK-NEXT: </FieldTypeBlock>
+  // CHECK-NEXT: <FieldTypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-NEXT: </ReferenceBlock>
+    // CHECK-NEXT: <Name abbrevid=4 op0=1/> blob data = 'J'
+  // CHECK-NEXT: </FieldTypeBlock>
+// CHECK-NEXT: </FunctionBlock>

clang-tools-extra/trunk/test/clang-doc/bc-namespace.cpp

+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: echo "" > %t/compile_flags.txt
+// RUN: cp "%s" "%t/test.cpp"
+// RUN: clang-doc --dump-intermediate -doxygen -p %t %t/test.cpp -output=%t/docs
+// RUN: llvm-bcanalyzer %t/docs/bc/8D042EFFC98B373450BC6B5B90A330C25A150E9C.bc --dump | FileCheck %s --check-prefix CHECK-A
+// RUN: llvm-bcanalyzer %t/docs/bc/E21AF79E2A9D02554BA090D10DF39FE273F5CDB5.bc --dump | FileCheck %s --check-prefix CHECK-B
+// RUN: llvm-bcanalyzer %t/docs/bc/39D3C95A5F7CE2BA4937BD7B01BAE09EBC2AD8AC.bc --dump | FileCheck %s --check-prefix CHECK-F
+// RUN: llvm-bcanalyzer %t/docs/bc/9A82CB33ED0FDF81EE383D31CD0957D153C5E840.bc --dump | FileCheck %s --check-prefix CHECK-FUNC
+// RUN: llvm-bcanalyzer %t/docs/bc/E9ABF7E7E2425B626723D41E76E4BC7E7A5BD775.bc --dump | FileCheck %s --check-prefix CHECK-E
+ 
+namespace A {
+// CHECK-A: <NamespaceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-A-NEXT: <USR abbrevid=4 op0=20 op1=141 op2=4 op3=46 op4=255 op5=201 op6=139 op7=55 op8=52 op9=80 op10=188 op11=107 op12=91 op13=144 op14=163 op15=48 op16=194 op17=90 op18=21 op19=14 op20=156/>
+  // CHECK-A-NEXT: <Name abbrevid=5 op0=1/> blob data = 'A'
+// CHECK-A-NEXT: </NamespaceBlock>
+  
+void f();
+
+}  // namespace A
+
+namespace A {
+
+void f(){};
+// CHECK-F: <FunctionBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-F-NEXT: <USR abbrevid=4 op0=20 op1=57 op2=211 op3=201 op4=90 op5=95 op6=124 op7=226 op8=186 op9=73 op10=55 op11=189 op12=123 op13=1 op14=186 op15=224 op16=158 op17=188 op18=42 op19=216 op20=172/>
+  // CHECK-F-NEXT: <Name abbrevid=5 op0=1/> blob data = 'f'
+  // CHECK-F-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-F-NEXT: <USR abbrevid=4 op0=20 op1=141 op2=4 op3=46 op4=255 op5=201 op6=139 op7=55 op8=52 op9=80 op10=188 op11=107 op12=91 op13=144 op14=163 op15=48 op16=194 op17=90 op18=21 op19=14 op20=156/>
+    // CHECK-F-NEXT: <Name abbrevid=5 op0=1/> blob data = 'A'
+    // CHECK-F-NEXT: <RefType abbrevid=6 op0=1/>
+    // CHECK-F-NEXT: <Field abbrevid=7 op0=1/>
+  // CHECK-F-NEXT: </ReferenceBlock>
+  // CHECK-F-NEXT: <DefLocation abbrevid=6 op0=24 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-F-NEXT: <Location abbrevid=7 op0=18 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-F-NEXT: <TypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-F-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-F-NEXT: <Name abbrevid=5 op0=4/> blob data = 'void'
+      // CHECK-F-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-F-NEXT: </ReferenceBlock>
+  // CHECK-F-NEXT: </TypeBlock>
+// CHECK-F-NEXT: </FunctionBlock>
+
+namespace B {
+// CHECK-B: <NamespaceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-B-NEXT: <USR abbrevid=4 op0=20 op1=226 op2=26 op3=247 op4=158 op5=42 op6=157 op7=2 op8=85 op9=75 op10=160 op11=144 op12=209 op13=13 op14=243 op15=159 op16=226 op17=115 op18=245 op19=205 op20=181/>
+  // CHECK-B-NEXT: <Name abbrevid=5 op0=1/> blob data = 'B'
+  // CHECK-B-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-B-NEXT: <USR abbrevid=4 op0=20 op1=141 op2=4 op3=46 op4=255 op5=201 op6=139 op7=55 op8=52 op9=80 op10=188 op11=107 op12=91 op13=144 op14=163 op15=48 op16=194 op17=90 op18=21 op19=14 op20=156/>
+    // CHECK-B-NEXT: <Name abbrevid=5 op0=1/> blob data = 'A'
+    // CHECK-B-NEXT: <RefType abbrevid=6 op0=1/>
+    // CHECK-B-NEXT: <Field abbrevid=7 op0=1/>
+  // CHECK-B-NEXT: </ReferenceBlock>
+// CHECK-B-NEXT: </NamespaceBlock>
+
+enum E { X };
+// CHECK-E: <EnumBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-E-NEXT: <USR abbrevid=4 op0=20 op1=233 op2=171 op3=247 op4=231 op5=226 op6=66 op7=91 op8=98 op9=103 op10=35 op11=212 op12=30 op13=118 op14=228 op15=188 op16=126 op17=122 op18=91 op19=215 op20=117/>
+  // CHECK-E-NEXT: <Name abbrevid=5 op0=1/> blob data = 'E'
+  // CHECK-E-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-E-NEXT: <USR abbrevid=4 op0=20 op1=226 op2=26 op3=247 op4=158 op5=42 op6=157 op7=2 op8=85 op9=75 op10=160 op11=144 op12=209 op13=13 op14=243 op15=159 op16=226 op17=115 op18=245 op19=205 op20=181/>
+    // CHECK-E-NEXT: <Name abbrevid=5 op0=1/> blob data = 'B'
+    // CHECK-E-NEXT: <RefType abbrevid=6 op0=1/>
+    // CHECK-E-NEXT: <Field abbrevid=7 op0=1/>
+  // CHECK-E-NEXT: </ReferenceBlock>
+  // CHECK-E-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-E-NEXT: <USR abbrevid=4 op0=20 op1=141 op2=4 op3=46 op4=255 op5=201 op6=139 op7=55 op8=52 op9=80 op10=188 op11=107 op12=91 op13=144 op14=163 op15=48 op16=194 op17=90 op18=21 op19=14 op20=156/>
+    // CHECK-E-NEXT: <Name abbrevid=5 op0=1/> blob data = 'A'
+    // CHECK-E-NEXT: <RefType abbrevid=6 op0=1/>
+    // CHECK-E-NEXT: <Field abbrevid=7 op0=1/>
+  // CHECK-E-NEXT: </ReferenceBlock>
+  // CHECK-E-NEXT: <DefLocation abbrevid=6 op0=56 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-E-NEXT: <Member abbrevid=8 op0=1/> blob data = 'X'
+// CHECK-E-NEXT: </EnumBlock>
+
+E func(int i) { return X; }
+// CHECK-FUNC: <FunctionBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-FUNC-NEXT: <USR abbrevid=4 op0=20 op1=154 op2=130 op3=203 op4=51 op5=237 op6=15 op7=223 op8=129 op9=238 op10=56 op11=61 op12=49 op13=205 op14=9 op15=87 op16=209 op17=83 op18=197 op19=232 op20=64/>
+  // CHECK-FUNC-NEXT: <Name abbrevid=5 op0=4/> blob data = 'func'
+  // CHECK-FUNC-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-FUNC-NEXT: <USR abbrevid=4 op0=20 op1=226 op2=26 op3=247 op4=158 op5=42 op6=157 op7=2 op8=85 op9=75 op10=160 op11=144 op12=209 op13=13 op14=243 op15=159 op16=226 op17=115 op18=245 op19=205 op20=181/>
+    // CHECK-FUNC-NEXT: <Name abbrevid=5 op0=1/> blob data = 'B'
+    // CHECK-FUNC-NEXT: <RefType abbrevid=6 op0=1/>
+    // CHECK-FUNC-NEXT: <Field abbrevid=7 op0=1/>
+  // CHECK-FUNC-NEXT: </ReferenceBlock>
+  // CHECK-FUNC-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-FUNC-NEXT: <USR abbrevid=4 op0=20 op1=141 op2=4 op3=46 op4=255 op5=201 op6=139 op7=55 op8=52 op9=80 op10=188 op11=107 op12=91 op13=144 op14=163 op15=48 op16=194 op17=90 op18=21 op19=14 op20=156/>
+    // CHECK-FUNC-NEXT: <Name abbrevid=5 op0=1/> blob data = 'A'
+    // CHECK-FUNC-NEXT: <RefType abbrevid=6 op0=1/>
+    // CHECK-FUNC-NEXT: <Field abbrevid=7 op0=1/>
+  // CHECK-FUNC-NEXT: </ReferenceBlock>
+  // CHECK-FUNC-NEXT: <DefLocation abbrevid=6 op0=76 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-FUNC-NEXT: <TypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-FUNC-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-FUNC-NEXT: <Name abbrevid=5 op0=12/> blob data = 'enum A::B::E'
+      // CHECK-FUNC-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-FUNC-NEXT: </ReferenceBlock>
+  // CHECK-FUNC-NEXT: </TypeBlock>
+  // CHECK-FUNC-NEXT: <FieldTypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-FUNC-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-FUNC-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-FUNC-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-FUNC-NEXT: </ReferenceBlock>
+    // CHECK-FUNC-NEXT: <Name abbrevid=4 op0=1/> blob data = 'i'
+  // CHECK-FUNC-NEXT: </FieldTypeBlock>
+// CHECK-FUNC-NEXT: </FunctionBlock>
+
+}  // namespace B
+}  // namespace A

clang-tools-extra/trunk/test/clang-doc/bc-record.cpp

+// This test requires Linux due to the system-dependent USR for the
+// inner class in function H.
+// REQUIRES: system-linux
+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: echo "" > %t/compile_flags.txt
+// RUN: cp "%s" "%t/test.cpp"
+// RUN: clang-doc --dump-intermediate -doxygen -p %t %t/test.cpp -output=%t/docs
+// RUN: llvm-bcanalyzer %t/docs/bc/ACE81AFA6627B4CEF2B456FB6E1252925674AF7E.bc --dump | FileCheck %s --check-prefix CHECK-A
+// RUN: llvm-bcanalyzer %t/docs/bc/FC07BD34D5E77782C263FA944447929EA8753740.bc --dump | FileCheck %s --check-prefix CHECK-B
+// RUN: llvm-bcanalyzer %t/docs/bc/1E3438A08BA22025C0B46289FF0686F92C8924C5.bc --dump | FileCheck %s --check-prefix CHECK-BC
+// RUN: llvm-bcanalyzer %t/docs/bc/06B5F6A19BA9F6A832E127C9968282B94619B210.bc --dump | FileCheck %s --check-prefix CHECK-C
+// RUN: llvm-bcanalyzer %t/docs/bc/0921737541208B8FA9BB42B60F78AC1D779AA054.bc --dump | FileCheck %s --check-prefix CHECK-D
+// RUN: llvm-bcanalyzer %t/docs/bc/289584A8E0FF4178A794622A547AA622503967A1.bc --dump | FileCheck %s --check-prefix CHECK-E
+// RUN: llvm-bcanalyzer %t/docs/bc/DEB4AC1CD9253CD9EF7FBE6BCAC506D77984ABD4.bc --dump | FileCheck %s --check-prefix CHECK-ECON
+// RUN: llvm-bcanalyzer %t/docs/bc/BD2BDEBD423F80BACCEA75DE6D6622D355FC2D17.bc --dump | FileCheck %s --check-prefix CHECK-EDES
+// RUN: llvm-bcanalyzer %t/docs/bc/E3B54702FABFF4037025BA194FC27C47006330B5.bc --dump | FileCheck %s --check-prefix CHECK-F
+// RUN: llvm-bcanalyzer %t/docs/bc/B6AC4C5C9F2EA3F2B3ECE1A33D349F4EE502B24E.bc --dump | FileCheck %s --check-prefix CHECK-H
+// RUN: llvm-bcanalyzer %t/docs/bc/6BA1EE2B3DAEACF6E4306F10AF44908F4807927C.bc --dump | FileCheck %s --check-prefix CHECK-I
+// RUN: llvm-bcanalyzer %t/docs/bc/5093D428CDC62096A67547BA52566E4FB9404EEE.bc --dump | FileCheck %s --check-prefix CHECK-PM
+// RUN: llvm-bcanalyzer %t/docs/bc/CA7C7935730B5EACD25F080E9C83FA087CCDC75E.bc --dump | FileCheck %s --check-prefix CHECK-X
+// RUN: llvm-bcanalyzer %t/docs/bc/641AB4A3D36399954ACDE29C7A8833032BF40472.bc --dump | FileCheck %s --check-prefix CHECK-Y
+
+void H() {
+  class I {};
+}
+// CHECK-H: <FunctionBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-H-NEXT: <USR abbrevid=4 op0=20 op1=182 op2=172 op3=76 op4=92 op5=159 op6=46 op7=163 op8=242 op9=179 op10=236 op11=225 op12=163 op13=61 op14=52 op15=159 op16=78 op17=229 op18=2 op19=178 op20=78/>
+  // CHECK-H-NEXT: <Name abbrevid=5 op0=1/> blob data = 'H'
+  // CHECK-H-NEXT: <DefLocation abbrevid=6 op0=24 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-H-NEXT: <TypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-H-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-H-NEXT: <Name abbrevid=5 op0=4/> blob data = 'void'
+      // CHECK-H-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-H-NEXT: </ReferenceBlock>
+  // CHECK-H-NEXT: </TypeBlock>
+// CHECK-H-NEXT: </FunctionBlock>
+
+
+// CHECK-I: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-I-NEXT: <USR abbrevid=4 op0=20 op1=107 op2=161 op3=238 op4=43 op5=61 op6=174 op7=172 op8=246 op9=228 op10=48 op11=111 op12=16 op13=175 op14=68 op15=144 op16=143 op17=72 op18=7 op19=146 op20=124/>
+  // CHECK-I-NEXT: <Name abbrevid=5 op0=1/> blob data = 'I'
+  // CHECK-I-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-I-NEXT: <USR abbrevid=4 op0=20 op1=182 op2=172 op3=76 op4=92 op5=159 op6=46 op7=163 op8=242 op9=179 op10=236 op11=225 op12=163 op13=61 op14=52 op15=159 op16=78 op17=229 op18=2 op19=178 op20=78/>
+    // CHECK-I-NEXT: <Name abbrevid=5 op0=1/> blob data = 'H'
+    // CHECK-I-NEXT: <RefType abbrevid=6 op0=3/>
+    // CHECK-I-NEXT: <Field abbrevid=7 op0=1/>
+  // CHECK-I-NEXT: </ReferenceBlock>
+  // CHECK-I-NEXT: <DefLocation abbrevid=6 op0=25 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-I-NEXT: <TagType abbrevid=8 op0=3/>
+// CHECK-I-NEXT: </RecordBlock>
+
+union A { int X; int Y; };
+// CHECK-A: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-A-NEXT: <USR abbrevid=4 op0=20 op1=172 op2=232 op3=26 op4=250 op5=102 op6=39 op7=180 op8=206 op9=242 op10=180 op11=86 op12=251 op13=110 op14=18 op15=82 op16=146 op17=86 op18=116 op19=175 op20=126/>
+  // CHECK-A-NEXT: <Name abbrevid=5 op0=1/> blob data = 'A'
+  // CHECK-A-NEXT: <DefLocation abbrevid=6 op0=53 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-A-NEXT: <TagType abbrevid=8 op0=2/>
+  // CHECK-A-NEXT: <MemberTypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-A-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-A-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-A-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-A-NEXT: </ReferenceBlock>
+    // CHECK-A-NEXT: <Name abbrevid=4 op0=1/> blob data = 'X'
+    // CHECK-A-NEXT: <Access abbrevid=5 op0=3/>
+  // CHECK-A-NEXT: </MemberTypeBlock>
+  // CHECK-A-NEXT: <MemberTypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-A-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-A-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-A-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-A-NEXT: </ReferenceBlock>
+    // CHECK-A-NEXT: <Name abbrevid=4 op0=1/> blob data = 'Y'
+    // CHECK-A-NEXT: <Access abbrevid=5 op0=3/>
+  // CHECK-A-NEXT: </MemberTypeBlock>
+// CHECK-A-NEXT: </RecordBlock>
+
+enum B { X, Y };
+// CHECK-B: <EnumBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-B-NEXT: <USR abbrevid=4 op0=20 op1=252 op2=7 op3=189 op4=52 op5=213 op6=231 op7=119 op8=130 op9=194 op10=99 op11=250 op12=148 op13=68 op14=71 op15=146 op16=158 op17=168 op18=117 op19=55 op20=64/>
+  // CHECK-B-NEXT: <Name abbrevid=5 op0=1/> blob data = 'B'
+  // CHECK-B-NEXT: <DefLocation abbrevid=6 op0=77 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-B-NEXT: <Member abbrevid=8 op0=1/> blob data = 'X'
+  // CHECK-B-NEXT: <Member abbrevid=8 op0=1/> blob data = 'Y'
+// CHECK-B-NEXT: </EnumBlock>
+
+enum class Bc { A, B };
+// CHECK-BC: <EnumBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-BC-NEXT: <USR abbrevid=4 op0=20 op1=30 op2=52 op3=56 op4=160 op5=139 op6=162 op7=32 op8=37 op9=192 op10=180 op11=98 op12=137 op13=255 op14=6 op15=134 op16=249 op17=44 op18=137 op19=36 op20=197/>
+  // CHECK-BC-NEXT: <Name abbrevid=5 op0=2/> blob data = 'Bc'
+  // CHECK-BC-NEXT: <DefLocation abbrevid=6 op0=86 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-BC-NEXT: <Scoped abbrevid=9 op0=1/>
+  // CHECK-BC-NEXT: <Member abbrevid=8 op0=1/> blob data = 'A'
+  // CHECK-BC-NEXT: <Member abbrevid=8 op0=1/> blob data = 'B'
+// CHECK-BC-NEXT: </EnumBlock>
+
+struct C { int i; };
+// CHECK-C: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-C-NEXT: <USR abbrevid=4 op0=20 op1=6 op2=181 op3=246 op4=161 op5=155 op6=169 op7=246 op8=168 op9=50 op10=225 op11=39 op12=201 op13=150 op14=130 op15=130 op16=185 op17=70 op18=25 op19=178 op20=16/>
+  // CHECK-C-NEXT: <Name abbrevid=5 op0=1/> blob data = 'C'
+  // CHECK-C-NEXT: <DefLocation abbrevid=6 op0=96 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-C-NEXT: <MemberTypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-C-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-C-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-C-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-C-NEXT: </ReferenceBlock>
+    // CHECK-C-NEXT: <Name abbrevid=4 op0=1/> blob data = 'i'
+    // CHECK-C-NEXT: <Access abbrevid=5 op0=3/>
+  // CHECK-C-NEXT: </MemberTypeBlock>
+// CHECK-C-NEXT: </RecordBlock>
+
+class D {};
+// CHECK-D: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-D-NEXT: <USR abbrevid=4 op0=20 op1=9 op2=33 op3=115 op4=117 op5=65 op6=32 op7=139 op8=143 op9=169 op10=187 op11=66 op12=182 op13=15 op14=120 op15=172 op16=29 op17=119 op18=154 op19=160 op20=84/>
+  // CHECK-D-NEXT: <Name abbrevid=5 op0=1/> blob data = 'D'
+  // CHECK-D-NEXT: <DefLocation abbrevid=6 op0=111 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-D-NEXT: <TagType abbrevid=8 op0=3/>
+// CHECK-D-NEXT: </RecordBlock>
+
+class E {
+public:
+  E() {}
+  ~E() {}
+
+protected:
+  void ProtectedMethod();
+};
+// CHECK-E: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-E-NEXT: <USR abbrevid=4 op0=20 op1=40 op2=149 op3=132 op4=168 op5=224 op6=255 op7=65 op8=120 op9=167 op10=148 op11=98 op12=42 op13=84 op14=122 op15=166 op16=34 op17=80 op18=57 op19=103 op20=161/>
+  // CHECK-E-NEXT: <Name abbrevid=5 op0=1/> blob data = 'E'
+  // CHECK-E-NEXT: <DefLocation abbrevid=6 op0=119 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-E-NEXT: <TagType abbrevid=8 op0=3/>
+// CHECK-E-NEXT: </RecordBlock>
+
+// CHECK-ECON: <FunctionBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-ECON-NEXT: <USR abbrevid=4 op0=20 op1=222 op2=180 op3=172 op4=28 op5=217 op6=37 op7=60 op8=217 op9=239 op10=127 op11=190 op12=107 op13=202 op14=197 op15=6 op16=215 op17=121 op18=132 op19=171 op20=212/>
+  // CHECK-ECON-NEXT: <Name abbrevid=5 op0=1/> blob data = 'E'
+    // CHECK-ECON-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-ECON-NEXT: <USR abbrevid=4 op0=20 op1=40 op2=149 op3=132 op4=168 op5=224 op6=255 op7=65 op8=120 op9=167 op10=148 op11=98 op12=42 op13=84 op14=122 op15=166 op16=34 op17=80 op18=57 op19=103 op20=161/>
+      // CHECK-ECON-NEXT: <Name abbrevid=5 op0=1/> blob data = 'E'
+      // CHECK-ECON-NEXT: <RefType abbrevid=6 op0=2/>
+      // CHECK-ECON-NEXT: <Field abbrevid=7 op0=1/>
+    // CHECK-ECON-NEXT: </ReferenceBlock>
+  // CHECK-ECON-NEXT: <IsMethod abbrevid=9 op0=1/>
+  // CHECK-ECON-NEXT: <DefLocation abbrevid=6 op0=121 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-ECON-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-ECON-NEXT: <USR abbrevid=4 op0=20 op1=40 op2=149 op3=132 op4=168 op5=224 op6=255 op7=65 op8=120 op9=167 op10=148 op11=98 op12=42 op13=84 op14=122 op15=166 op16=34 op17=80 op18=57 op19=103 op20=161/>
+    // CHECK-ECON-NEXT: <Name abbrevid=5 op0=1/> blob data = 'E'
+    // CHECK-ECON-NEXT: <RefType abbrevid=6 op0=2/>
+    // CHECK-ECON-NEXT: <Field abbrevid=7 op0=2/>
+  // CHECK-ECON-NEXT: </ReferenceBlock>
+  // CHECK-ECON-NEXT: <TypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-ECON-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-ECON-NEXT: <Name abbrevid=5 op0=4/> blob data = 'void'
+      // CHECK-ECON-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-ECON-NEXT: </ReferenceBlock>
+  // CHECK-ECON-NEXT: </TypeBlock>
+// CHECK-ECON-NEXT: </FunctionBlock>
+
+// CHECK-EDES: <FunctionBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-EDES-NEXT: <USR abbrevid=4 op0=20 op1=189 op2=43 op3=222 op4=189 op5=66 op6=63 op7=128 op8=186 op9=204 op10=234 op11=117 op12=222 op13=109 op14=102 op15=34 op16=211 op17=85 op18=252 op19=45 op20=23/>
+  // CHECK-EDES-NEXT: <Name abbrevid=5 op0=2/> blob data = '~E'
+  // CHECK-EDES-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-EDES-NEXT: <USR abbrevid=4 op0=20 op1=40 op2=149 op3=132 op4=168 op5=224 op6=255 op7=65 op8=120 op9=167 op10=148 op11=98 op12=42 op13=84 op14=122 op15=166 op16=34 op17=80 op18=57 op19=103 op20=161/>
+    // CHECK-EDES-NEXT: <Name abbrevid=5 op0=1/> blob data = 'E'
+    // CHECK-EDES-NEXT: <RefType abbrevid=6 op0=2/>
+    // CHECK-EDES-NEXT: <Field abbrevid=7 op0=1/>
+  // CHECK-EDES-NEXT: </ReferenceBlock>
+  // CHECK-EDES-NEXT: <IsMethod abbrevid=9 op0=1/>
+  // CHECK-EDES-NEXT: <DefLocation abbrevid=6 op0=122 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-EDES-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-EDES-NEXT: <USR abbrevid=4 op0=20 op1=40 op2=149 op3=132 op4=168 op5=224 op6=255 op7=65 op8=120 op9=167 op10=148 op11=98 op12=42 op13=84 op14=122 op15=166 op16=34 op17=80 op18=57 op19=103 op20=161/>
+    // CHECK-EDES-NEXT: <Name abbrevid=5 op0=1/> blob data = 'E'
+    // CHECK-EDES-NEXT: <RefType abbrevid=6 op0=2/>
+    // CHECK-EDES-NEXT: <Field abbrevid=7 op0=2/>
+  // CHECK-EDES-NEXT: </ReferenceBlock>
+  // CHECK-EDES-NEXT: <TypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-EDES-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-EDES-NEXT: <Name abbrevid=5 op0=4/> blob data = 'void'
+      // CHECK-EDES-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-EDES-NEXT: </ReferenceBlock>
+  // CHECK-EDES-NEXT: </TypeBlock>
+// CHECK-EDES-NEXT: </FunctionBlock>
+
+void E::ProtectedMethod() {}
+// CHECK-PM: <FunctionBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-PM-NEXT: <USR abbrevid=4 op0=20 op1=80 op2=147 op3=212 op4=40 op5=205 op6=198 op7=32 op8=150 op9=166 op10=117 op11=71 op12=186 op13=82 op14=86 op15=110 op16=79 op17=185 op18=64 op19=78 op20=238/>
+  // CHECK-PM-NEXT: <Name abbrevid=5 op0=15/> blob data = 'ProtectedMethod'
+  // CHECK-PM-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-PM-NEXT: <USR abbrevid=4 op0=20 op1=40 op2=149 op3=132 op4=168 op5=224 op6=255 op7=65 op8=120 op9=167 op10=148 op11=98 op12=42 op13=84 op14=122 op15=166 op16=34 op17=80 op18=57 op19=103 op20=161/>
+    // CHECK-PM-NEXT: <Name abbrevid=5 op0=1/> blob data = 'E'
+    // CHECK-PM-NEXT: <RefType abbrevid=6 op0=2/>
+    // CHECK-PM-NEXT: <Field abbrevid=7 op0=1/>
+  // CHECK-PM-NEXT: </ReferenceBlock>
+  // CHECK-PM-NEXT: <IsMethod abbrevid=9 op0=1/>
+  // CHECK-PM-NEXT: <DefLocation abbrevid=6 op0=184 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-PM-NEXT: <Location abbrevid=7 op0=125 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-PM-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-PM-NEXT: <USR abbrevid=4 op0=20 op1=40 op2=149 op3=132 op4=168 op5=224 op6=255 op7=65 op8=120 op9=167 op10=148 op11=98 op12=42 op13=84 op14=122 op15=166 op16=34 op17=80 op18=57 op19=103 op20=161/>
+    // CHECK-PM-NEXT: <Name abbrevid=5 op0=1/> blob data = 'E'
+    // CHECK-PM-NEXT: <RefType abbrevid=6 op0=2/>
+    // CHECK-PM-NEXT: <Field abbrevid=7 op0=2/>
+  // CHECK-PM-NEXT: </ReferenceBlock>
+  // CHECK-PM-NEXT: <TypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-PM-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-PM-NEXT: <Name abbrevid=5 op0=4/> blob data = 'void'
+      // CHECK-PM-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-PM-NEXT: </ReferenceBlock>
+  // CHECK-PM-NEXT: </TypeBlock>
+// CHECK-PM-NEXT: </FunctionBlock>
+
+
+
+class F : virtual private D, public E {};
+// CHECK-F: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-F-NEXT: <USR abbrevid=4 op0=20 op1=227 op2=181 op3=71 op4=2 op5=250 op6=191 op7=244 op8=3 op9=112 op10=37 op11=186 op12=25 op13=79 op14=194 op15=124 op16=71 op17=0 op18=99 op19=48 op20=181/>
+  // CHECK-F-NEXT: <Name abbrevid=5 op0=1/> blob data = 'F'
+  // CHECK-F-NEXT: <DefLocation abbrevid=6 op0=213 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-F-NEXT: <TagType abbrevid=8 op0=3/>
+  // CHECK-F-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-F-NEXT: <USR abbrevid=4 op0=20 op1=40 op2=149 op3=132 op4=168 op5=224 op6=255 op7=65 op8=120 op9=167 op10=148 op11=98 op12=42 op13=84 op14=122 op15=166 op16=34 op17=80 op18=57 op19=103 op20=161/>
+    // CHECK-F-NEXT: <Name abbrevid=5 op0=1/> blob data = 'E'
+    // CHECK-F-NEXT: <RefType abbrevid=6 op0=2/>
+    // CHECK-F-NEXT: <Field abbrevid=7 op0=2/>
+  // CHECK-F-NEXT: </ReferenceBlock>
+  // CHECK-F-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-F-NEXT: <USR abbrevid=4 op0=20 op1=9 op2=33 op3=115 op4=117 op5=65 op6=32 op7=139 op8=143 op9=169 op10=187 op11=66 op12=182 op13=15 op14=120 op15=172 op16=29 op17=119 op18=154 op19=160 op20=84/>
+    // CHECK-F-NEXT: <Name abbrevid=5 op0=1/> blob data = 'D'
+    // CHECK-F-NEXT: <RefType abbrevid=6 op0=2/>
+    // CHECK-F-NEXT: <Field abbrevid=7 op0=3/>
+  // CHECK-F-NEXT: </ReferenceBlock>
+// CHECK-F-NEXT: </RecordBlock>
+
+class X {
+  class Y {};
+};
+// CHECK-X: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-X-NEXT: <USR abbrevid=4 op0=20 op1=202 op2=124 op3=121 op4=53 op5=115 op6=11 op7=94 op8=172 op9=210 op10=95 op11=8 op12=14 op13=156 op14=131 op15=250 op16=8 op17=124 op18=205 op19=199 op20=94/>
+  // CHECK-X-NEXT: <Name abbrevid=5 op0=1/> blob data = 'X'
+  // CHECK-X-NEXT: <DefLocation abbrevid=6 op0=233 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-X-NEXT: <TagType abbrevid=8 op0=3/>
+// CHECK-X-NEXT: </RecordBlock>
+
+// CHECK-Y: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+  // CHECK-Y-NEXT: <USR abbrevid=4 op0=20 op1=100 op2=26 op3=180 op4=163 op5=211 op6=99 op7=153 op8=149 op9=74 op10=205 op11=226 op12=156 op13=122 op14=136 op15=51 op16=3 op17=43 op18=244 op19=4 op20=114/>
+  // CHECK-Y-NEXT: <Name abbrevid=5 op0=1/> blob data = 'Y'
+  // CHECK-Y-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-Y-NEXT: <USR abbrevid=4 op0=20 op1=202 op2=124 op3=121 op4=53 op5=115 op6=11 op7=94 op8=172 op9=210 op10=95 op11=8 op12=14 op13=156 op14=131 op15=250 op16=8 op17=124 op18=205 op19=199 op20=94/>
+    // CHECK-Y-NEXT: <Name abbrevid=5 op0=1/> blob data = 'X'
+    // CHECK-Y-NEXT: <RefType abbrevid=6 op0=2/>
+    // CHECK-Y-NEXT: <Field abbrevid=7 op0=1/>
+  // CHECK-Y-NEXT: </ReferenceBlock>
+  // CHECK-Y-NEXT: <DefLocation abbrevid=6 op0=234 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-Y-NEXT: <TagType abbrevid=8 op0=3/>
+// CHECK-Y-NEXT: </RecordBlock>