Changing CodeView Debug info Type record output

[nilanjana_basu]

Summary

CodeView Debug info Type records were emitted as a series of bytes. With this latest change, it will be emitted as a set of directives, showing the size and value of each record field.

[nilanjana_basu]

Added extra checks in the COFF test cases. Resolved the circular dependency created between MC & DebugInfo libraries. Fixed a bug for comments added for CodeViewDebug Info in the assembly file, that got introduced with the last change.

[rnk]

+@hans, this has been up for six days, but I haven't found time to do a deeper code review. Would you mind doing a round of review for Nilanjana?

llvm/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h

183

I would recommend using git-clang-format to fix formatting issues in just the parts of the code that your patch touches. If I'm not around, you should be able to ask Bob or Amy how to use this tool. It requires some git usage. There are other small formatting issues that need fixing, but I don't want to highlight them all.

llvm/test/DebugInfo/COFF/types-basic.ll

515

Hm, we should do something about LF_FIELDLIST. The members should get directives. Maybe that's out of scope for this change. I think it's already an improvement.

[nilanjana_basu]

Ran git-clang-format to rectify formatting issues. Removed a few unnecessary comments that were left over.

[nilanjana_basu]

Changed FieldList output to make it more readable in a set of bytes format.

[rnk]

I realized that @hans is on vacation. @dblaikie, do you mind taking a look at the code here, since you have some passing familiarity with the virtues of the project, and we discussed the code the other day (how to avoid circular dependence)?

[dblaikie]

llvm/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h

35

extra ';' at the end of this line (& could use "= default;" instead of "{}")

184–185

LLVM style tends to avoid "else" after a conditional return/break/etc: https://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return

202–204

LLVM code doesn't usually have braces around single-line blocks (here and elsewhere in this review)

llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp

270

What else can you be doing other than reading or writing? (what is the semantic difference in this (& similar) code change?)

llvm/test/DebugInfo/COFF/asm.ll

2

Seems like overkill to double all these tests, perhaps?

[nilanjana_basu]

Changed code formatting to adhere to llvm coding standards as pointed out in code review comments.

[rnk]

llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp

270

I think this makes some sense, since the new mode is "streaming", which is notionally similar to writing. If we're "not reading" then we are producing some kind of output, either bytes or symbolic structured data.

llvm/test/DebugInfo/COFF/asm.ll

2

My recommendation was to test both codepaths, direct object emission and via textual assembly and confirm that info comes out the same. But, this test and many others don't exercise type information, so this extra run isn't really testing anything.

I would recommend reverting changes to test files that don't contain any lines matching LF_, since those are an indication of the presence of type records.

[nilanjana_basu]

llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp

270

There are 3 modes - reading (for deserializing), writing (for serializing), & streaming (which uses MCStreamer to emit directives to the assembly file).

llvm/test/DebugInfo/COFF/asm.ll

2

These tests emit & check the same end result, but they go through different paths of the code. One creates the code view record from the object file directly, & checks it. The other one creates the assembly file (the current changes get executed in this path), converts it to object file, & then checks the code view record from it. This is to double check that both the newly added code, & the original code path work correctly. Also, when I run all the tests in COFF using llvm-lit, there is a delay of 0.6s added (originally runtime 1.4s, now takes 2s).

llvm/test/DebugInfo/COFF/types-basic.ll

515

I changed it to the old style of emitting a set of bytes. I can improve this later in another commit.

[dblaikie]

llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp

270

Hmm, I couldn't really see (from as much as a glance as I managed) how different the streaming and writing codepaths are - given that DWARF doesn't have this distinction. Could you describe why CodeView does? (what's different about the streaming V writing that motivates the need for both - having conditional code around computing complex comments is fine, but I wouldn't expect many other differences)

llvm/test/DebugInfo/COFF/asm.ll

2

Yeah, I tend to be a bit over-fussy about testing - in this case my premise is usually "could you write a bug that causes one path to fail and not the other & that wouldn't be caught by another test" - I'd have expected the difference between writing and streaming (if there needs to be one - short of skipping computing complex comments) to be at a relatively low layer of the stack - so many choices about the ways types are described in CodeView might happen up in common layers that are shared between streaming and writing. So having lots of tests that retest those same codepaths would be sub-optimal to me.

Not just with regards to the runtime cost of the tests (though that's part of it - moreso than the wall time on our machines when fully parallelized - but the buildbots, sanitizers, etc, and the sort of "death by a thousand cuts" situation of testing takes longer when lots of these choices are made) but also the maintenance of them - if you change the output in some way and have to touch more tests because of this, get screen fulls of failures that are all about the same bug, etc.

[rnk]

I think this is almost ready, I went to approve it but I found some more final things to fix before committing.

llvm/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h

37

Please add some comments describing the three modes of this class.

llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp

39

Please use C++ style single line comments for consistency.

249–261

Maybe this could be simplified to avoid duplicate logic like this:

uint8_t FinalZero = 0;
mapInteger(FinalZero);

llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp

48–54

We have to be careful here, this could introduce a bug when long class names are involved. The long-type-name.ll test case exists to exercise this code. I believe it doesn't fail because we write the type once, then read it, then stream it, so it gets truncated the first time around.

Is there anything wrong with using the isWriting() code path here, or should we use the !isReading pattern? It seems the same.

llvm/test/DebugInfo/COFF/asm.ll

2

I think I would be fine with leaving the extra testing in then if it's short. Or you could remove it. Either way is fine with me.

[nilanjana_basu]

llvm/test/DebugInfo/COFF/asm.ll

2

Have reverted redundant tests (files that do not have type records). Will submit in the next patch.

[nilanjana_basu]

llvm/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h

37

Comments will be added in the next patch beside the constructor for each mode.

llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp

48–54

Right. The streaming mode comes after the writing followed by reading mode, so the names should already be truncated by then.
Yes, there was duplicate code. Fixed it.

270

The "streaming" code path uses the MCStreamer interface to write meaningful representation of CodeView debug info type records, whereas the "writing" code path uses BinaryStreamWriter interface to serialize CodeView debug info type records to a set of bytes. There is little difference between both these paths at the high level of TypeRecordMapping (mostly taking care of large names by truncating them for "writing" mode, that is not required for streaming mode), & most of the difference is seen during its implementation at the CodeViewRecordIO level, where they both use different interfaces for emitting output.

llvm/test/DebugInfo/COFF/asm.ll

2

Point taken. According to my understanding, the "streaming" path is used while writing to the assembly file, whereas it is not used while emitting the debug info when directly compiled to the object file. I wanted to check that the code view debug info record retrieved from the object file that was formed directly & from the object file compiled from the assembly, should be the same. This will test that the streamer mode is emitting the correct output.

[nilanjana_basu]

Removed redundant tests (that did not involve type records). Added a few meaningful comments, & removed duplicate code as per reviewer suggestions.

[rnk]

llvm/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h

49–50

This runs over the 80 character limit, I would recommend writing it on the previous line, here and in one other place.

llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp

39

Needs wrapping

[nilanjana_basu]

Fixed formatting related issues as per reviewer suggestions

[rnk]

lgtm

[nilanjana_basu]

Fixed the "memory used out of scope" bug introduced because of this change

[rnk]

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

643–649

It would be ideal if we didn't re-construct the entire pipeline and heap allocate the visitor and printer inside the loop. Is it possible to set it up outside the loop? I recall that there were problems with the CommentBlock accumulating multiple comments. Is it enough to add CommentBlock.clear(), and then move the rest outside the loop?

653–665

llvm::make_unique<ScopedPrinter>(CommentOS) is preferred to avoid repeating ScopedPrinter. It is modeled on std::make_unique from C++14.

655

ditto

[nilanjana_basu]

Changes made as per comments - using llvm::make_unique instead of casting to unique_ptr, & creating TypeVisitorCallback pipeline, printer & visitor once for all type records.

[nilanjana_basu]

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

643–649

Yes. That works & looks more efficient than before. The new patch reflects this change.

653–665

Has been fixed in next patch.

655

Has been fixed in next patch.

[rnk]

lgtm!

llvm/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h

 //===- CVTypeVisitor.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_CVTYPEVISITOR_H
 #define LLVM_DEBUGINFO_CODEVIEW_CVTYPEVISITOR_H
 
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace codeview {
 class TypeCollection;
 class TypeVisitorCallbacks;
 
 enum VisitorDataSource {
   VDS_BytesPresent, // The record bytes are passed into the visitation
                     // function.  The algorithm should first deserialize them
                     // before passing them on through the pipeline.
   VDS_BytesExternal // The record bytes are not present, and it is the
                     // responsibility of the visitor callback interface to
                     // supply the bytes.
 };
 
 Error visitTypeRecord(CVType &Record, TypeIndex Index,
                       TypeVisitorCallbacks &Callbacks,
                       VisitorDataSource Source = VDS_BytesPresent);
+Error visitTypeRecord(CVType &Record, TypeIndex Index,
+                      TypeVisitorCallbackPipeline &Callbacks,
+                      VisitorDataSource Source = VDS_BytesPresent);
 Error visitTypeRecord(CVType &Record, TypeVisitorCallbacks &Callbacks,
                       VisitorDataSource Source = VDS_BytesPresent);
 
 Error visitMemberRecord(CVMemberRecord Record, TypeVisitorCallbacks &Callbacks,
                         VisitorDataSource Source = VDS_BytesPresent);
 Error visitMemberRecord(TypeLeafKind Kind, ArrayRef<uint8_t> Record,
                         TypeVisitorCallbacks &Callbacks);
 

llvm/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h

 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/BinaryStreamWriter.h"
 #include "llvm/Support/Error.h"
 #include <cassert>
 #include <cstdint>
 #include <type_traits>
 
 namespace llvm {
+
 namespace codeview {
 
+class CodeViewRecordStreamer {
+ public:
+  virtual void EmitBytes(StringRef Data) = 0;
+  virtual void EmitIntValue(uint64_t Value, unsigned Size) = 0;
+  virtual ~CodeViewRecordStreamer() {};
+};
+
 class CodeViewRecordIO {
   uint32_t getCurrentOffset() const {
-    return (isWriting()) ? Writer->getOffset() : Reader->getOffset();
+    if (isWriting())
+      return Writer->getOffset();
+    else if (isReading())
+      return Reader->getOffset();
+    else
+      return 0;
   }
 
 public:
   explicit CodeViewRecordIO(BinaryStreamReader &Reader) : Reader(&Reader) {}
   explicit CodeViewRecordIO(BinaryStreamWriter &Writer) : Writer(&Writer) {}
+  explicit CodeViewRecordIO(CodeViewRecordStreamer &Streamer) : Streamer(&Streamer) {}
 
   Error beginRecord(Optional<uint32_t> MaxLength);
   Error endRecord();
 
   Error mapInteger(TypeIndex &TypeInd);
 
-  bool isReading() const { return Reader != nullptr; }
-  bool isWriting() const { return !isReading(); }
+  bool isStreaming() const { return (Streamer != nullptr) && (Reader == nullptr) && (Writer == nullptr); }
+  bool isReading() const { return (Reader != nullptr) && (Streamer == nullptr) && (Writer == nullptr); }
+  bool isWriting() const { return (Writer != nullptr) && (Streamer == nullptr) && (Reader == nullptr); }
 
   uint32_t maxFieldLength() const;
 
   template <typename T> Error mapObject(T &Value) {
+    if (isStreaming()) {
+      StringRef BytesSR = StringRef((reinterpret_cast<const char *>(&Value)), sizeof(Value));
+      Streamer->EmitBytes(BytesSR);
+      incrStreamedLen(sizeof(T));
+      return Error::success();
+    }
+
     if (isWriting())
       return Writer->writeObject(Value);
 
     const T *ValuePtr;
     if (auto EC = Reader->readObject(ValuePtr))
       return EC;
     Value = *ValuePtr;
     return Error::success();
   }
 
   template <typename T> Error mapInteger(T &Value) {
+    if (isStreaming()) {
+      Streamer->EmitIntValue((int)Value, sizeof(T));
+      incrStreamedLen(sizeof(T));
+      return Error::success();
+    }
+
     if (isWriting())
       return Writer->writeInteger(Value);
 
     return Reader->readInteger(Value);
   }
 
   template <typename T> Error mapEnum(T &Value) {
-    if (sizeof(Value) > maxFieldLength())
+    if (!isStreaming() && sizeof(Value) > maxFieldLength())
       return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
 
     using U = typename std::underlying_type<T>::type;
     U X;
-    if (isWriting())
+
+    if (isWriting() || isStreaming())
       X = static_cast<U>(Value);
 
     if (auto EC = mapInteger(X))
       return EC;
+
     if (isReading())
       Value = static_cast<T>(X);
+
     return Error::success();
   }
 
   Error mapEncodedInteger(int64_t &Value);
   Error mapEncodedInteger(uint64_t &Value);
   Error mapEncodedInteger(APSInt &Value);
   Error mapStringZ(StringRef &Value);
   Error mapGuid(GUID &Guid);
 
   Error mapStringZVectorZ(std::vector<StringRef> &Value);
 
   template <typename SizeType, typename T, typename ElementMapper>
   Error mapVectorN(T &Items, const ElementMapper &Mapper) {
     SizeType Size;
-    if (isWriting()) {
+    if (isStreaming()) {
+      Size = static_cast<SizeType>(Items.size());
+      Streamer->EmitIntValue(Size, sizeof(Size));
+      incrStreamedLen(sizeof(Size)); // add 1 for the delimiter
+
+      for (auto &X : Items) {
+        if (auto EC = Mapper(*this, X))
+          return EC;
+      }
+    }
+    else  if (isWriting()) {
       Size = static_cast<SizeType>(Items.size());
       if (auto EC = Writer->writeInteger(Size))
         return EC;
 
       for (auto &X : Items) {
         if (auto EC = Mapper(*this, X))
           return EC;
       }
     } else {
       if (auto EC = Reader->readInteger(Size))
         return EC;
       for (SizeType I = 0; I < Size; ++I) {
         typename T::value_type Item;
         if (auto EC = Mapper(*this, Item))
           return EC;
         Items.push_back(Item);
       }
     }
 
     return Error::success();
   }
 
   template <typename T, typename ElementMapper>
   Error mapVectorTail(T &Items, const ElementMapper &Mapper) {
-    if (isWriting()) {
+    if (isStreaming() || isWriting()) {
       for (auto &Item : Items) {
         if (auto EC = Mapper(*this, Item))
           return EC;
       }
     } else {
       typename T::value_type Field;
       // Stop when we run out of bytes or we hit record padding bytes.
       while (!Reader->empty() && Reader->peek() < 0xf0 /* LF_PAD0 */) {
         if (auto EC = Mapper(*this, Field))
           return EC;
         Items.push_back(Field);
       }
     }
     return Error::success();
   }
 
   Error mapByteVectorTail(ArrayRef<uint8_t> &Bytes);
   Error mapByteVectorTail(std::vector<uint8_t> &Bytes);
 
   Error padToAlignment(uint32_t Align);
   Error skipPadding();
 
+  uint64_t getStreamedLen() {
+    if(isStreaming())
+      return StreamedLen;
+    else
+      return 0;
+  }
+
 private:
+  void emitEncodedSignedInteger(const int64_t &Value);
+  void emitEncodedUnsignedInteger(const uint64_t &Value);
   Error writeEncodedSignedInteger(const int64_t &Value);
   Error writeEncodedUnsignedInteger(const uint64_t &Value);
 
+  void incrStreamedLen(const uint64_t &Len) { 
+    if(isStreaming()) {
+      StreamedLen += Len;
+    }
+  }
+
+  void resetStreamedLen() { 
+    if(isStreaming()) 
+      StreamedLen = 4; // The record prefix is 4 bytes long
+  }
+
   struct RecordLimit {
     uint32_t BeginOffset;
     Optional<uint32_t> MaxLength;
 
     Optional<uint32_t> bytesRemaining(uint32_t CurrentOffset) const {
       if (!MaxLength.hasValue())
         return None;
       assert(CurrentOffset >= BeginOffset);
 
       uint32_t BytesUsed = CurrentOffset - BeginOffset;
       if (BytesUsed >= *MaxLength)
         return 0;
       return *MaxLength - BytesUsed;
     }
   };
 
   SmallVector<RecordLimit, 2> Limits;
 
   BinaryStreamReader *Reader = nullptr;
   BinaryStreamWriter *Writer = nullptr;
+  CodeViewRecordStreamer *Streamer = nullptr;
+  uint64_t StreamedLen = 0;
 };
 
 } // end namespace codeview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_CODEVIEWRECORDIO_H

llvm/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h

 class BinaryStreamReader;
 class BinaryStreamWriter;
 
 namespace codeview {
 class TypeRecordMapping : public TypeVisitorCallbacks {
 public:
   explicit TypeRecordMapping(BinaryStreamReader &Reader) : IO(Reader) {}
   explicit TypeRecordMapping(BinaryStreamWriter &Writer) : IO(Writer) {}
+  explicit TypeRecordMapping(CodeViewRecordStreamer &Streamer) : IO(Streamer) {}
 
   using TypeVisitorCallbacks::visitTypeBegin;
   Error visitTypeBegin(CVType &Record) override;
+  Error visitTypeBegin(CVType &Record, TypeIndex Index) override;
   Error visitTypeEnd(CVType &Record) override;
 
   Error visitMemberBegin(CVMemberRecord &Record) override;
   Error visitMemberEnd(CVMemberRecord &Record) override;
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   Error visitKnownRecord(CVType &CVR, Name##Record &Record) override;
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \

llvm/include/llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h

Error visitMemberEnd(CVMemberRecord &Record) override {
     }
     return Error::success();
   }
 
   void addCallbackToPipeline(TypeVisitorCallbacks &Callbacks) {
     Pipeline.push_back(&Callbacks);
   }
 
+  void addCallbackToPipelineFront(TypeVisitorCallbacks &Callbacks) {
+    auto CallBackItr = Pipeline.begin();
+    Pipeline.insert(CallBackItr, &Callbacks);
+  }
+
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   Error visitKnownRecord(CVType &CVR, Name##Record &Record) override {         \
     return visitKnownRecordImpl(CVR, Record);                                  \
   }
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   Error visitKnownMember(CVMemberRecord &CVMR, Name##Record &Record)           \
       override {                                                               \
     return visitKnownMemberImpl(CVMR, Record);                                 \

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/CodeGen/TargetFrameLowering.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
+#include "llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/CodeViewRecordIO.h"
 #include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h"
 #include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h"
 #include "llvm/DebugInfo/CodeView/EnumTables.h"
 #include "llvm/DebugInfo/CodeView/Line.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"

 #include <limits>
 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::codeview;
 
+namespace {
+  class CVMCAdapter : public CodeViewRecordStreamer {
+   public:
+    CVMCAdapter(MCStreamer &OS) : OS(&OS) {}
+
+    void EmitBytes(StringRef Data) {
+      OS->EmitBytes(Data);
+    }
+
+    void EmitIntValue(uint64_t Value, unsigned Size) {
+      OS->EmitIntValue(Value, Size);
+    }
+
+   private:
+    MCStreamer *OS = nullptr;
+  };
+}
+
 static CPUType mapArchToCVCPUType(Triple::ArchType Type) {
   switch (Type) {
   case Triple::ArchType::x86:
     return CPUType::Pentium3;
   case Triple::ArchType::x86_64:
     return CPUType::X64;
   case Triple::ArchType::thumb:
     return CPUType::Thumb;
void CodeViewDebug::emitTypeInformation() {
   }
 
   TypeTableCollection Table(TypeTable.records());
   Optional<TypeIndex> B = Table.getFirst();
   while (B) {
     // This will fail if the record data is invalid.
     CVType Record = Table.getType(*B);
 
-    if (OS.isVerboseAsm()) {
-      // Emit a block comment describing the type record for readability.
-      SmallString<512> CommentBlock;
-      raw_svector_ostream CommentOS(CommentBlock);
+    TypeVisitorCallbackPipeline Pipeline;
+    CVMCAdapter CVMCOS(OS);
+    TypeRecordMapping typeMapping(CVMCOS);
+
+    if (OS.isVerboseAsm()) {
+      // Emit a block comment describing the type record for readability.
       ScopedPrinter SP(CommentOS);
       SP.setPrefix(CommentPrefix);
       TypeDumpVisitor TDV(Table, &SP, false);
+      Pipeline.addCallbackToPipeline(TDV);
+    }
+    Pipeline.addCallbackToPipeline(typeMapping);
+
+    auto RecordLen = Record.length();
+    auto RecordKind = Record.kind();
+    OS.EmitIntValue(RecordLen-2, 2); // Size is hardcoded as per format requirement, check the reason for the "-2"?
+    OS.EmitIntValue(RecordKind, sizeof(RecordKind));
+
+    Error E = codeview::visitTypeRecord(Record, *B, Pipeline);
 
-      Error E = codeview::visitTypeRecord(Record, *B, TDV);
-      if (E) {
-        logAllUnhandledErrors(std::move(E), errs(), "error: ");
-        llvm_unreachable("produced malformed type record");
-      }
+
+    if (OS.isVerboseAsm()) {
       // emitRawComment will insert its own tab and comment string before
       // the first line, so strip off our first one. It also prints its own
       // newline.
       OS.emitRawComment(
           CommentOS.str().drop_front(CommentPrefix.size() - 1).rtrim());
     }
-    OS.EmitBinaryData(Record.str_data());
     B = Table.getNext(*B);
   }
 }
 
 void CodeViewDebug::emitTypeGlobalHashes() {
   if (TypeTable.empty())
     return;
 

llvm/lib/DebugInfo/CodeView/CVTypeVisitor.cpp

struct VisitHelper {
   VisitHelper(TypeVisitorCallbacks &Callbacks, VisitorDataSource Source)
       : Visitor((Source == VDS_BytesPresent) ? Pipeline : Callbacks) {
     if (Source == VDS_BytesPresent) {
       Pipeline.addCallbackToPipeline(Deserializer);
       Pipeline.addCallbackToPipeline(Callbacks);
     }
   }
 
+  VisitHelper(TypeVisitorCallbackPipeline &Callbacks, VisitorDataSource Source)
+      : Visitor((Source == VDS_BytesPresent) ? Pipeline : Callbacks) {
+    if (Source == VDS_BytesPresent) {
+      Pipeline = Callbacks;
+      Pipeline.addCallbackToPipelineFront(Deserializer);
+    }
+  }
+
   TypeDeserializer Deserializer;
   TypeVisitorCallbackPipeline Pipeline;
   CVTypeVisitor Visitor;
 };
 }
 
 Error llvm::codeview::visitTypeRecord(CVType &Record, TypeIndex Index,
                                       TypeVisitorCallbacks &Callbacks,
                                       VisitorDataSource Source) {
   VisitHelper V(Callbacks, Source);
   return V.Visitor.visitTypeRecord(Record, Index);
 }
 
+Error llvm::codeview::visitTypeRecord(CVType &Record, TypeIndex Index,
+                                      TypeVisitorCallbackPipeline &Callbacks,
+                                      VisitorDataSource Source) {
+  VisitHelper V(Callbacks, Source);
+  return V.Visitor.visitTypeRecord(Record, Index);
+}
+
 Error llvm::codeview::visitTypeRecord(CVType &Record,
                                       TypeVisitorCallbacks &Callbacks,
                                       VisitorDataSource Source) {
   VisitHelper V(Callbacks, Source);
   return V.Visitor.visitTypeRecord(Record);
 }
 
 Error llvm::codeview::visitTypeStream(const CVTypeArray &Types,

llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp

 using namespace llvm;
 using namespace llvm::codeview;
 
 Error CodeViewRecordIO::beginRecord(Optional<uint32_t> MaxLength) {
   RecordLimit Limit;
   Limit.MaxLength = MaxLength;
   Limit.BeginOffset = getCurrentOffset();
   Limits.push_back(Limit);
+  resetStreamedLen();
   return Error::success();
 }
 
 Error CodeViewRecordIO::endRecord() {
   assert(!Limits.empty() && "Not in a record!");
   Limits.pop_back();
   // We would like to assert that we actually read / wrote all the bytes that we
   // expected to for this record, but unfortunately we can't do this.  Some
   // producers such as MASM over-allocate for certain types of records and
   // commit the extraneous data, so when reading we can't be sure every byte
   // will have been read.  And when writing we over-allocate temporarily since
   // we don't know how big the record is until we're finished writing it, so
   // even though we don't commit the extraneous data, we still can't guarantee
   // we're at the end of the allocated data.
+
+  /* Padding to align with 4byte boundaries */
+  if(isStreaming()) {
+    uint32_t Align = getStreamedLen() % 4;
+    if (Align == 0)
+      return Error::success();
+
+    int PaddingBytes = 4 - Align;
+    while (PaddingBytes > 0) {
+      char Pad = static_cast<uint8_t>(LF_PAD0 + PaddingBytes);
+      StringRef BytesSR = StringRef(&Pad, sizeof(Pad));
+      Streamer->EmitBytes(BytesSR);
+      --PaddingBytes;
+    }
+  }
   return Error::success();
 }
 
 uint32_t CodeViewRecordIO::maxFieldLength() const {
+  if(isStreaming()) {
+    return 0;
+  }
   assert(!Limits.empty() && "Not in a record!");
 
   // The max length of the next field is the minimum of all lengths that would
   // be allowed by any of the sub-records we're in.  In practice, we can only
   // ever be at most 1 sub-record deep (in a FieldList), but this works for
   // the general case.
   uint32_t Offset = getCurrentOffset();
   Optional<uint32_t> Min = Limits.front().bytesRemaining(Offset);
if (Leaf < LF_PAD0)
     return Error::success();
   // Leaf is greater than 0xf0. We should advance by the number of bytes in
   // the low 4 bits.
   unsigned BytesToAdvance = Leaf & 0x0F;
   return Reader->skip(BytesToAdvance);
 }
 
 Error CodeViewRecordIO::mapByteVectorTail(ArrayRef<uint8_t> &Bytes) {
-  if (isWriting()) {
+  if (isStreaming()) {
+    char *Buffer = (char *)malloc(Bytes.size()*sizeof(uint8_t));
+    for (unsigned I = 0; I < Bytes.size(); ++I)
+      Buffer[I] = uint8_t(Bytes[I]);
+    StringRef BytesSR = StringRef(Buffer, Bytes.size());
+    Streamer->EmitBytes(BytesSR);
+    incrStreamedLen(Bytes.size());
+  }
+  else if (isWriting()) {
     if (auto EC = Writer->writeBytes(Bytes))
       return EC;
   } else {
     if (auto EC = Reader->readBytes(Bytes, Reader->bytesRemaining()))
       return EC;
   }
   return Error::success();
 }
 
 Error CodeViewRecordIO::mapByteVectorTail(std::vector<uint8_t> &Bytes) {
   ArrayRef<uint8_t> BytesRef(Bytes);
   if (auto EC = mapByteVectorTail(BytesRef))
     return EC;
   if (!isWriting())
     Bytes.assign(BytesRef.begin(), BytesRef.end());
 
   return Error::success();
 }
 
 Error CodeViewRecordIO::mapInteger(TypeIndex &TypeInd) {
-  if (isWriting()) {
+  if (isStreaming()) {
+    Streamer->EmitIntValue(TypeInd.getIndex(), sizeof(TypeInd.getIndex()));
+    incrStreamedLen(sizeof(TypeInd.getIndex()));
+  }
+  else if (isWriting()) {
     if (auto EC = Writer->writeInteger(TypeInd.getIndex()))
       return EC;
-    return Error::success();
   }
-
+  else {
     uint32_t I;
     if (auto EC = Reader->readInteger(I))
       return EC;
     TypeInd.setIndex(I);
+  }
   return Error::success();
 }
 
 Error CodeViewRecordIO::mapEncodedInteger(int64_t &Value) {
-  if (isWriting()) {
+  if (isStreaming()) {
+    if (Value >= 0)
+      emitEncodedUnsignedInteger(static_cast<uint64_t>(Value));
+    else
+      emitEncodedSignedInteger(Value);
+  }
+  else if (isWriting()) {
     if (Value >= 0) {
       if (auto EC = writeEncodedUnsignedInteger(static_cast<uint64_t>(Value)))
         return EC;
     } else {
       if (auto EC = writeEncodedSignedInteger(Value))
         return EC;
     }
   } else {
     APSInt N;
     if (auto EC = consume(*Reader, N))
       return EC;
     Value = N.getExtValue();
   }
 
   return Error::success();
 }
 
 Error CodeViewRecordIO::mapEncodedInteger(uint64_t &Value) {
-  if (isWriting()) {
+  if (isStreaming()) {
+    emitEncodedUnsignedInteger(Value);
+  }
+  else if (isWriting()) {
     if (auto EC = writeEncodedUnsignedInteger(Value))
       return EC;
   } else {
     APSInt N;
     if (auto EC = consume(*Reader, N))
       return EC;
     Value = N.getZExtValue();
   }
   return Error::success();
 }
 
 Error CodeViewRecordIO::mapEncodedInteger(APSInt &Value) {
-  if (isWriting()) {
+  if (isStreaming()) {
+    if (Value.isSigned())
+      emitEncodedSignedInteger(Value.getSExtValue());
+    else
+      emitEncodedUnsignedInteger(Value.getZExtValue());
+  }
+  else if (isWriting()) {
     if (Value.isSigned())
       return writeEncodedSignedInteger(Value.getSExtValue());
     return writeEncodedUnsignedInteger(Value.getZExtValue());
   }
-
+  else
     return consume(*Reader, Value);
+  return Error::success();
 }
 
 Error CodeViewRecordIO::mapStringZ(StringRef &Value) {
-  if (isWriting()) {
+  if (isStreaming()) {
+    auto NullTerminatedString = StringRef(Value.data(), Value.size() + 1);
+    Streamer->EmitBytes(NullTerminatedString);
+    incrStreamedLen(NullTerminatedString.size());
+  }
+  else if (isWriting()) {
     // Truncate if we attempt to write too much.
     StringRef S = Value.take_front(maxFieldLength() - 1);
     if (auto EC = Writer->writeCString(S))
       return EC;
   } else {
     if (auto EC = Reader->readCString(Value))
       return EC;
   }
   return Error::success();
 }
 
 Error CodeViewRecordIO::mapGuid(GUID &Guid) {
   constexpr uint32_t GuidSize = 16;
+
+  if (isStreaming()) {
+    StringRef GuidSR = StringRef((reinterpret_cast<const char *>(&Guid)), GuidSize);
+    Streamer->EmitBytes(GuidSR);
+    incrStreamedLen(GuidSize);
+    return Error::success();
+  }
+
   if (maxFieldLength() < GuidSize)
     return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
 
   if (isWriting()) {
     if (auto EC = Writer->writeBytes(Guid.Guid))
       return EC;
   } else {
     ArrayRef<uint8_t> GuidBytes;
     if (auto EC = Reader->readBytes(GuidBytes, GuidSize))
       return EC;
     memcpy(Guid.Guid, GuidBytes.data(), GuidSize);
   }
   return Error::success();
 }
 
 Error CodeViewRecordIO::mapStringZVectorZ(std::vector<StringRef> &Value) {
-  if (isWriting()) {
+
+  if (isStreaming()) {
+    for (auto V : Value) {
+      if(auto EC = mapStringZ(V))
+        return EC;
+    }
+    Streamer->EmitIntValue(0, 1);
+  }
+  else if (isWriting()) {
     for (auto V : Value) {
       if (auto EC = mapStringZ(V))
         return EC;
     }
     if (auto EC = Writer->writeInteger<uint8_t>(0))
       return EC;
   } else {
     StringRef S;
     if (auto EC = mapStringZ(S))
       return EC;
     while (!S.empty()) {
       Value.push_back(S);
       if (auto EC = mapStringZ(S))
         return EC;
     };
   }
   return Error::success();
 }
 
+void CodeViewRecordIO::emitEncodedSignedInteger(const int64_t &Value) {
+  assert(Value < 0 && "Encoded integer is not signed!");
+  if (Value >= std::numeric_limits<int8_t>::min()) {
+    Streamer->EmitIntValue(LF_CHAR,2);
+    Streamer->EmitIntValue(Value,1);
+    incrStreamedLen(3);
+  } else if (Value >= std::numeric_limits<int16_t>::min()) {
+    Streamer->EmitIntValue(LF_SHORT,2);
+    Streamer->EmitIntValue(Value,2);
+    incrStreamedLen(4);
+  } else if (Value >= std::numeric_limits<int32_t>::min()) {
+    Streamer->EmitIntValue(LF_LONG,2);
+    Streamer->EmitIntValue(Value,4);
+    incrStreamedLen(6);
+  } else {
+    Streamer->EmitIntValue(LF_QUADWORD,2);
+    Streamer->EmitIntValue(Value,4);
+    incrStreamedLen(6);
+  }
+}
+
+void CodeViewRecordIO::emitEncodedUnsignedInteger(const uint64_t &Value) {
+  if (Value < LF_NUMERIC) {
+    Streamer->EmitIntValue(Value,2);
+    incrStreamedLen(2);
+  } else if (Value <= std::numeric_limits<uint16_t>::max()) {
+    Streamer->EmitIntValue(LF_USHORT,2);
+    Streamer->EmitIntValue(Value,2);
+    incrStreamedLen(4);
+  } else if (Value <= std::numeric_limits<uint32_t>::max()) {
+    Streamer->EmitIntValue(LF_ULONG,2);
+    Streamer->EmitIntValue(Value,4); // ? can we assume Value to be an unsigned int? if not, which emit API should be used?
+    incrStreamedLen(6);
+  } else {
+    Streamer->EmitIntValue(LF_UQUADWORD,2);
+    Streamer->EmitIntValue(Value,4);
+    incrStreamedLen(6);
+  }
+}
+
 Error CodeViewRecordIO::writeEncodedSignedInteger(const int64_t &Value) {
   assert(Value < 0 && "Encoded integer is not signed!");
   if (Value >= std::numeric_limits<int8_t>::min()) {
     if (auto EC = Writer->writeInteger<uint16_t>(LF_CHAR))
       return EC;
     if (auto EC = Writer->writeInteger<int8_t>(Value))
       return EC;
   } else if (Value >= std::numeric_limits<int16_t>::min()) {

llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp

Error operator()(CodeViewRecordIO &IO, OneMethodRecord &Method) const {
     error(IO.mapInteger(Method.Attrs.Attrs));
     if (IsFromOverloadList) {
       uint16_t Padding = 0;
       error(IO.mapInteger(Padding));
     }
     error(IO.mapInteger(Method.Type));
     if (Method.isIntroducingVirtual()) {
       error(IO.mapInteger(Method.VFTableOffset));
-    } else if (!IO.isWriting())
+    } else if (IO.isReading())
       Method.VFTableOffset = -1;
 
     if (!IsFromOverloadList)
       error(IO.mapStringZ(Method.Name));
 
     return Error::success();
   }
 
 private:
   bool IsFromOverloadList;
 };
 }
 
 static Error mapNameAndUniqueName(CodeViewRecordIO &IO, StringRef &Name,
                                   StringRef &UniqueName, bool HasUniqueName) {
-  if (IO.isWriting()) {
+  if (IO.isStreaming()) {
+    error(IO.mapStringZ(Name));
+    if (HasUniqueName)
+      error(IO.mapStringZ(UniqueName));
+  }
+  else if (IO.isWriting()) {
     // Try to be smart about what we write here.  We can't write anything too
     // large, so if we're going to go over the limit, truncate both the name
     // and unique name by the same amount.
     size_t BytesLeft = IO.maxFieldLength();
     if (HasUniqueName) {
       size_t BytesNeeded = Name.size() + UniqueName.size() + 2;
       StringRef N = Name;
       StringRef U = UniqueName;
       if (BytesNeeded > BytesLeft) {
Error TypeRecordMapping::visitTypeBegin(CVType &CVR) {
   if (CVR.kind() != TypeLeafKind::LF_FIELDLIST &&
       CVR.kind() != TypeLeafKind::LF_METHODLIST)
     MaxLen = MaxRecordLength - sizeof(RecordPrefix);
   error(IO.beginRecord(MaxLen));
   TypeKind = CVR.kind();
   return Error::success();
 }
 
+Error TypeRecordMapping::visitTypeBegin(CVType &CVR, TypeIndex Index) {
+  return visitTypeBegin(CVR);
+}
+
 Error TypeRecordMapping::visitTypeEnd(CVType &Record) {
   assert(TypeKind.hasValue() && "Not in a type mapping!");
   assert(!MemberKind.hasValue() && "Still in a member mapping!");
 
   error(IO.endRecord());
 
   TypeKind.reset();
   return Error::success();
Error TypeRecordMapping::visitMemberBegin(CVMemberRecord &Record) {
   MemberKind = Record.Kind;
   return Error::success();
 }
 
 Error TypeRecordMapping::visitMemberEnd(CVMemberRecord &Record) {
   assert(TypeKind.hasValue() && "Not in a type mapping!");
   assert(MemberKind.hasValue() && "Not in a member mapping!");
 
-  if (!IO.isWriting()) {
+  if (IO.isReading()) {
     if (auto EC = IO.skipPadding())
       return EC;
   }
 
   MemberKind.reset();
   error(IO.endRecord());
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ModifierRecord &Record) {
   error(IO.mapInteger(Record.ModifiedType));
   error(IO.mapEnum(Record.Modifiers));
-
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           ProcedureRecord &Record) {
   error(IO.mapInteger(Record.ReturnType));
   error(IO.mapEnum(Record.CallConv));
   error(IO.mapEnum(Record.Options));
Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ArgListRecord &Record) {
   error(IO.mapVectorN<uint32_t>(
       Record.ArgIndices,
       [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));
-
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           StringListRecord &Record) {
   error(IO.mapVectorN<uint32_t>(
       Record.StringIndices,
       [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, PointerRecord &Record) {
   error(IO.mapInteger(Record.ReferentType));
   error(IO.mapInteger(Record.Attrs));
 
   if (Record.isPointerToMember()) {
-    if (!IO.isWriting())
+    if(IO.isReading())
       Record.MemberInfo.emplace();
 
     MemberPointerInfo &M = *Record.MemberInfo;
     error(IO.mapInteger(M.ContainingType));
     error(IO.mapEnum(M.Representation));
   }
 
   return Error::success();
Error TypeRecordMapping::visitKnownRecord(CVType &CVR, BitFieldRecord &Record) {
   error(IO.mapInteger(Record.BitOffset));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           VFTableShapeRecord &Record) {
   uint16_t Size;
-  if (IO.isWriting()) {
+  if (!IO.isReading()) {
     ArrayRef<VFTableSlotKind> Slots = Record.getSlots();
     Size = Slots.size();
     error(IO.mapInteger(Size));
 
     for (size_t SlotIndex = 0; SlotIndex < Slots.size(); SlotIndex += 2) {
       uint8_t Byte = static_cast<uint8_t>(Slots[SlotIndex]) << 4;
       if ((SlotIndex + 1) < Slots.size()) {
         Byte |= static_cast<uint8_t>(Slots[SlotIndex + 1]);
Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, VFTableRecord &Record) {
   error(IO.mapInteger(Record.CompleteClass));
   error(IO.mapInteger(Record.OverriddenVFTable));
   error(IO.mapInteger(Record.VFPtrOffset));
   uint32_t NamesLen = 0;
-  if (IO.isWriting()) {
+  if (!IO.isReading()) {
     for (auto Name : Record.MethodNames)
       NamesLen += Name.size() + 1;
   }
   error(IO.mapInteger(NamesLen));
   error(IO.mapVectorTail(
       Record.MethodNames,
       [](CodeViewRecordIO &IO, StringRef &S) { return IO.mapStringZ(S); }));
 

llvm/test/DebugInfo/COFF/anonymous-struct.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; struct S {
 ;   int x;
 ;   struct { int a; } ;
 ; } s;
 
 ; CHECK: CodeViewTypes [

llvm/test/DebugInfo/COFF/asm.ll

 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 -O0 < %s | FileCheck --check-prefix=X86 %s
+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 -o - -O0 -filetype=obj < %s | llvm-readobj -S --sr --codeview | FileCheck --check-prefix=OBJ32 %s
 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 -o - -O0 < %s | llvm-mc -triple=i686-pc-win32 -filetype=obj | llvm-readobj -S --sr --codeview | FileCheck --check-prefix=OBJ32 %s
 ; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32 -O0 < %s | FileCheck --check-prefix=X64 %s
+; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32 -o - -O0 -filetype=obj < %s | llvm-readobj -S --sr --codeview | FileCheck --check-prefix=OBJ64 %s
 ; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32 -o - -O0 < %s | llvm-mc -triple=x86_64-pc-win32 -filetype=obj | llvm-readobj -S --sr --codeview | FileCheck --check-prefix=OBJ64 %s
 
 ; This LL file was generated by running clang on the following code:
 ; D:\asm.c:
 ;  1 void g(void);
 ;  2
 ;  3 void f(void) {
 ;  4   __asm align 4;

llvm/test/DebugInfo/COFF/big-type.ll

 ; RUN: llc -filetype=obj < %s | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; We need three continuation records for this.
 
 ; CHECK-LABEL: FieldList (0x1000)
 ; CHECK-NEXT: TypeLeafKind: LF_FIELDLIST (0x1203)
 ; CHECK-NEXT: Enumerator {
 ; CHECK-NEXT:   TypeLeafKind: LF_ENUMERATE (0x1502)
 ; CHECK-NEXT:   AccessSpecifier: Public (0x3)

llvm/test/DebugInfo/COFF/class-options-common.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 ;
 ; Command to generate function-options.ll
 ; $ clang++ class-options-common.cpp -S -emit-llvm -g -gcodeview -o class-options-common.ll
 
 
 
 ; // Basically, there are two Property (class-options) expectations on each type:
 ; // One for class forwarding reference, the other for class definition.

llvm/test/DebugInfo/COFF/const-unnamed-member.ll

 ; RUN: llc -filetype=obj < %s | llvm-readobj --codeview - | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj --codeview - | FileCheck %s
 
 ; Objective-C++ source demonstrating the issue:
 ; void (^b)(void) = []() {};
 
 ; C++ source derived and modified from:
 ; struct S {
 ;   struct {
 ;     int a;

llvm/test/DebugInfo/COFF/cpp-mangling.ll

 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 -o - -O0 -filetype=obj < %s \
 ; RUN:   | llvm-readobj --codeview | FileCheck %s
+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 -o - -O0 < %s \
+; RUN:   | llvm-mc -filetype=obj --triple=i386-windows \
+; RUN:   | llvm-readobj --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; namespace foo {
 ; int bar(int x) { return x * 2; }
 ; }
 ; template <typename T, int (*)(int)>
 ; void fn_tmpl() {}
 ; template void fn_tmpl<int, foo::bar>();

llvm/test/DebugInfo/COFF/defer-complete-type.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; Both A and B should get forward declarations and complete definitions for this
 ; example.
 
 ; C++ source to regenerate:
 ; $ cat t.cpp
 ; struct B { int b; };
 ; struct A { B *b; };

llvm/test/DebugInfo/COFF/dlang.ll

 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc -filetype=obj < %s | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
 
 ; ASM:      .short  4412                    # Record kind: S_COMPILE3
 ; ASM-NEXT: .long   68                      # Flags and language
 ; ASM-NEXT: .short  208                     # CPUType
 
 ; OBJ-LABEL: Compile3Sym {
 ; OBJ-NEXT:    Kind: S_COMPILE3 (0x113C)
 ; OBJ-NEXT:    Language: D (0x44)

llvm/test/DebugInfo/COFF/enum-co.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; Command to generate enum-co.ll
 ; $ clang++ enum-co.cpp -S -emit-llvm -g -gcodeview -o enum-co.ll
 ;
 ;
 ; #define DEFINE_FUNCTION(T) \
 ;   T Func_##T(T &arg) { return arg; };
 ;

llvm/test/DebugInfo/COFF/enum.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; Generated from the following C++ source:
 ; enum E : int { BLAH };
 ; E e;
 
 ; CHECK:     CodeViewTypes [
 ; CHECK:       FieldList (0x1000) {
 ; CHECK-NEXT:    TypeLeafKind: LF_FIELDLIST (0x1203)

llvm/test/DebugInfo/COFF/fp-stack.ll

 ; RUN: llc -mtriple=i686-windows-msvc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc -mtriple=i686-windows-msvc < %s -filetype=obj | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
+; RUN: llc -mtriple=i686-windows-msvc < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc18.0.0"
 
 define double @f(double %p1) !dbg !4 {
 entry:
   %sub = fsub double -0.000000e+00, %p1, !dbg !16
   tail call void @llvm.dbg.value(metadata double %sub, metadata !10, metadata !14), !dbg !15
   ret double %sub

llvm/test/DebugInfo/COFF/fpo-csrs.ll

 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc -filetype=obj < %s | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i386-windows | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
 
 ; C source:
 ; int getval(void);
 ; void usevals(int, ...);
 ; int csr1() {
 ;   int a = getval();
 ;   usevals(a);
 ;   usevals(a);

llvm/test/DebugInfo/COFF/fpo-realign-vframe.ll

 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc -filetype=obj < %s | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i386-windows | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
 
 ; PR38857
 
 ; When stack realignment is required by dynamic allocas are not used, the
 ; compiler will address locals with the ESP register. However, if call argument
 ; set up uses PUSH instructions, ESP may vary over the course of the function.
 ; This means it's not useful as a base register for describing the locations of
 ; variables. Instead, our CodeView output prefers to use the VFRAME virtual

llvm/test/DebugInfo/COFF/fpo-shrink-wrap.ll

 ; RUN: llc -enable-shrink-wrap=true < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc -enable-shrink-wrap=true -filetype=obj < %s | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
+; RUN: llc -enable-shrink-wrap=true < %s | llvm-mc -filetype=obj --triple=i386-windows | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
 
 ; C source:
 ; int doSomething(int*);
 ; int __fastcall shrink_wrap_basic(int a, int b, int c, int d) {
 ;   if (a < b)
 ;     return a;
 ;   for (int i = c; i < d; ++i)
 ;     doSomething(&c);

llvm/test/DebugInfo/COFF/function-options.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 ;
 ; Command to generate function-options.ll
 ; $ clang++ function-options.cpp -S -emit-llvm -g -gcodeview -o function-options.ll
 ;
 ;
 ; #define DEFINE_FUNCTION(T) \
 ;   T Func_##T(T &arg) { return arg; }
 ;

llvm/test/DebugInfo/COFF/global-constants.ll

 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s --check-prefix=OBJ
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s --check-prefix=OBJ
 
 ; C++ source to regenerate:
 ; const int Test1 = 1;
 ; int main() {
 ;   return Test1;
 ; }
 ; $ clang t.cpp -S -emit-llvm -g -gcodeview -o t.ll
 

llvm/test/DebugInfo/COFF/global_visibility.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 ;
 ; This test verifies global variables are emitted within the correct scope.
 ;
 ; -- global_visibility.cpp ----------------------------------------------------
 ;  1  
 ;  2  int global_int = 0;
 ;  3  
 ;  4  template <typename T> struct A {

llvm/test/DebugInfo/COFF/globals.ll

 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s --check-prefix=OBJ
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s --check-prefix=OBJ
 ; RUN: llc < %s -filetype=obj | obj2yaml | FileCheck %s --check-prefix=YAML
 
 ; C++ source to regenerate:
 ; $ cat t.cpp
 ; int first;
 ; template <typename T> struct A { static const int comdat = 3; };
 ; const int *middle = &A<void>::comdat;
 ; int last;

llvm/test/DebugInfo/COFF/inheritance.ll

 ; RUN: llc < %s -filetype=obj -o - | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s -o - | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; $ cat t.cpp
 ; struct A { int a; };
 ; struct B : virtual A { int b; virtual int get() { return b; } };
 ; struct C : virtual A { int c; virtual int get() { return c; } };
 ; struct D : B, C {
 ;   virtual void f(); // make vbptr not offset zero

llvm/test/DebugInfo/COFF/inlining-files.ll

 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 < %s -filetype=obj | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
 
 ; This LL file was generated by running 'clang -O1 -g -gcodeview' on the
 ; volatile int x;
 ; static inline void file_change(void) {
 ;   x++;
 ; #include "t.inc"
 ;   x++;
 ; }

llvm/test/DebugInfo/COFF/inlining-header.ll

 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 < %s -filetype=obj | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
 
 ; This C++ source should run and you should be able to step through the volatile
 ; modifications to x in windbg.
 ; # 1 "t.cpp" 2
 ; volatile int x;
 ;
 ; # 1 "./t.h" 1
 ; inline void f() {

llvm/test/DebugInfo/COFF/inlining-levels.ll

 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 < %s -filetype=obj | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
 
 ; This LL file was generated by running 'clang -O1 -g -gcodeview' on the
 ; following code:
 ; int volatile x;
 ; static inline void f() {
 ;   ++x;
 ; }
 ; static inline void g() {

llvm/test/DebugInfo/COFF/inlining-padding.ll

 ; RUN: llc < %s -filetype=obj -o - | llvm-readobj --codeview --codeview-subsection-bytes | FileCheck %s
+; RUN: llc < %s -o - | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj --codeview --codeview-subsection-bytes | FileCheck %s
 
 ; Check how we pad out the LF_FUNC_ID records. The 00F3F2F1 bytes in LeafData are
 ; what's interesting here.
 
 ; CHECK:  FuncId (0x1002) {
 ; CHECK:    TypeLeafKind: LF_FUNC_ID (0x1601)
 ; CHECK:    Name: a
 ; CHECK:    LeafData (

llvm/test/DebugInfo/COFF/inlining-same-name.ll

 ; RUN: llc -mtriple=x86_64-windows-msvc < %s -filetype=obj -o - | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc -mtriple=x86_64-windows-msvc < %s -o - | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; We should only get one func id record, and both inlinees should point to it,
 ; even though there are two DISubprograms.
 
 ; CHECK:  FuncId (0x1002) {
 ; CHECK-NEXT:    TypeLeafKind: LF_FUNC_ID (0x1601)
 ; CHECK-NEXT:    ParentScope: 0x0
 ; CHECK-NEXT:    FunctionType: void () (0x1001)

llvm/test/DebugInfo/COFF/inlining.ll

 ; ASM: .section .debug$T,"dr"
 ; ASM: .long 4 # Debug section magic
 ; ASM: # ArgList (0x1000) {
 ; ASM: #   TypeLeafKind: LF_ARGLIST (0x1201)
 ; ASM: #   NumArgs: 0
 ; ASM: #   Arguments [
 ; ASM: #   ]
 ; ASM: # }
-; ASM: .byte   0x06, 0x00, 0x01, 0x12
-; ASM: .byte   0x00, 0x00, 0x00, 0x00
 ; ASM: # Procedure (0x1001) {
 ; ASM: #   TypeLeafKind: LF_PROCEDURE (0x1008)
 ; ASM: #   ReturnType: void (0x3)
 ; ASM: #   CallingConvention: NearC (0x0)
 ; ASM: #   FunctionOptions [ (0x0)
 ; ASM: #   ]
 ; ASM: #   NumParameters: 0
 ; ASM: #   ArgListType: () (0x1000)
 ; ASM: # }
-; ASM: .byte   0x0e, 0x00, 0x08, 0x10
-; ASM: .byte   0x03, 0x00, 0x00, 0x00
-; ASM: .byte   0x00, 0x00, 0x00, 0x00
-; ASM: .byte   0x00, 0x10, 0x00, 0x00
 ; ASM: # FuncId (0x1002) {
 ; ASM: #   TypeLeafKind: LF_FUNC_ID (0x1601)
 ; ASM: #   ParentScope: 0x0
 ; ASM: #   FunctionType: void () (0x1001)
 ; ASM: #   Name: bar
 ; ASM: # }
-; ASM: .byte   0x0e, 0x00, 0x01, 0x16
-; ASM: .byte   0x00, 0x00, 0x00, 0x00
-; ASM: .byte   0x01, 0x10, 0x00, 0x00
-; ASM: .byte   0x62, 0x61, 0x72, 0x00
 ; ASM: # FuncId (0x1003) {
 ; ASM: #   TypeLeafKind: LF_FUNC_ID (0x1601)
 ; ASM: #   ParentScope: 0x0
 ; ASM: #   FunctionType: void () (0x1001)
 ; ASM: #   Name: foo
 ; ASM: # }
-; ASM: .byte   0x0e, 0x00, 0x01, 0x16
-; ASM: .byte   0x00, 0x00, 0x00, 0x00
-; ASM: .byte   0x01, 0x10, 0x00, 0x00
-; ASM: .byte   0x66, 0x6f, 0x6f, 0x00
 
 ; We should only the LF_FUNC_ID records that we needed to reference.
 ; OBJ: CodeViewTypes [
 ; OBJ:   Section: .debug$T
 ; OBJ:   ArgList (0x1000) {
 ; OBJ:     TypeLeafKind: LF_ARGLIST (0x1201)
 ; OBJ:     NumArgs: 0
 ; OBJ:   }

llvm/test/DebugInfo/COFF/int8-char-type.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; Use character types for all 8-bit integers. The VS debugger doesn't cope well
 ; with the T_[U]INT1 types. Non-C language frontends are likely use the normal
 ; DW_ATE_[un]signed encoding for all integer types if they don't have distinct
 ; integer types for characters types. This was PR30552.
 
 ; CHECK-LABEL: GlobalData {
 ; CHECK-NEXT:    Kind: S_GDATA32 (0x110D)

llvm/test/DebugInfo/COFF/lambda.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj - --codeview | FileCheck %s
 ;
 ; Verify lambda routines are emitted properly in CodeView.
 ;
 ; The original source code:
 ; -----------------------------------------------------------------------------
 ; int main(int argc, char* argv[], char* arge[]) {
 ;   auto Lambda = [argc](int count) -> int { return argc == count ? 1 : 0; };
 ;   return Lambda(0);

llvm/test/DebugInfo/COFF/lexicalblock.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj - --codeview | FileCheck %s
 ;
 ; -- lexicablock.cxx begin ----------------------------------------------------
 ; int main(int argc, char *argv[]) {
 ;   int localA = 1;
 ;
 ;   { // S_BLOCK32 not emitted because it has multiple address ranges.
 ;     int localB = 2;
 ;

llvm/test/DebugInfo/COFF/lines-difile.ll

 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc < %s -filetype=obj | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
 
 ; Test what happens when we have two DIFile entries with differing slashes.
 ; Make sure we only emit one file checksum entry.
 
 ; C++ source, compiled as:
 ; $ clang -S -emit-llvm -g -gcodeview ../t.cpp -o t.ll
 ; struct Foo { Foo(); };
 ; extern int global;

llvm/test/DebugInfo/COFF/local-constant.ll

 ; RUN: llc -mtriple=x86_64-windows-msvc < %s -filetype=obj | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
+; RUN: llc -mtriple=x86_64-windows-msvc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
 
 ; This LL file was generated by running 'clang -g -gcodeview' on the
 ; following code:
 ; void useint(int);
 ; void constant_var() {
 ;   int x = 42;
 ;   useint(x);
 ;   useint(x);

llvm/test/DebugInfo/COFF/local-variable-gap.ll

 ; RUN: llc -mtriple=x86_64-windows-msvc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc -mtriple=x86_64-windows-msvc < %s -filetype=obj | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
+; RUN: llc -mtriple=x86_64-windows-msvc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
 
 ; This test attempts to exercise gaps in local variables. The local variable 'p'
 ; will end up in some CSR (esi), which will be used in both the BB scheduled
 ; discontiguously out of line and the normal return BB. The best way to encode
 ; this is to use a LocalVariableAddrGap. If the gap is too large, multiple
 ; ranges should be emitted.
 
 ; Source to regenerate:

llvm/test/DebugInfo/COFF/local-variables.ll

 ; RUN: llc -mtriple=x86_64-windows-msvc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc -mtriple=x86_64-windows-msvc < %s -filetype=obj | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
+; RUN: llc -mtriple=x86_64-windows-msvc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
 
 ; This LL file was generated by running 'clang -g -gcodeview' on the
 ; following code:
 ;  1: extern "C" volatile int x;
 ;  2: extern "C" void capture(int *p);
 ;  3: static __forceinline inline void will_be_inlined() {
 ;  4:   int v = 3;
 ;  5:   capture(&v);

llvm/test/DebugInfo/COFF/long-name.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj --codeview | FileCheck %s
 
 ; CHECK: {{.*}}Proc{{.*}}Sym {
 ; CHECK:   Kind: S_GPROC32_ID (0x1147)
 ; CHECK:   FunctionType: {{A+}} (0x1002)
 ; CHECK:   CodeOffset: f+0x0
 ; CHECK:   Segment: 0x0
 ; CHECK:   Flags [ (0x0)
 ; CHECK:   ]

llvm/test/DebugInfo/COFF/long-type-name.ll

 ; RUN: llc %s -o - -filetype=obj | llvm-readobj --codeview | FileCheck %s
+; RUN: llc %s -o - | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj --codeview | FileCheck %s
 
 ; CHECK: Struct (0x1000) {
 ; CHECK:   TypeLeafKind: LF_STRUCTURE (0x1505)
 ; CHECK:   MemberCount: 0
 ; CHECK:   Properties [ (0x280)
 ; CHECK:     ForwardReference (0x80)
 ; CHECK:     HasUniqueName (0x200)
 ; CHECK:   ]

llvm/test/DebugInfo/COFF/multifile.ll

 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 -O0 < %s | FileCheck --check-prefix=X86 %s
+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 -o - -O0 < %s -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ32 %s
 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 -o - -O0 < %s | llvm-mc -triple=i686-pc-win32 -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ32 %s
 ; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32 -O0 < %s | FileCheck --check-prefix=X64 %s
+; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32 -o - -O0 < %s -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ64 %s
 ; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32 -o - -O0 < %s | llvm-mc -triple=x86_64-pc-win32 -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ64 %s
 
 ; This LL file was generated by running clang on the following code:
 ; D:\input.c:
 ;  1 void g(void);
 ;  2
 ;  3 void f(void) {
 ;  4 #line 1 "one.c"

llvm/test/DebugInfo/COFF/multifunction.ll

 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 -O0 < %s | FileCheck --check-prefix=X86 %s
+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 -o - -O0 < %s -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ32 %s
 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 -o - -O0 < %s | llvm-mc -triple=i686-pc-win32 -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ32 %s
 ; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32 -O0 < %s | FileCheck --check-prefix=X64 %s
+; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32 -o - -O0 < %s -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ64 %s
 ; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32 -o - -O0 < %s | llvm-mc -triple=x86_64-pc-win32 -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ64 %s
 
 ; This LL file was generated by running clang on the following code:
 ; D:\source.c:
 ;  1 void z(void);
 ;  2
 ;  3 void x(void) {
 ;  4   z();

llvm/test/DebugInfo/COFF/nested-types.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; struct HasNested {
 ;   enum InnerEnum { _BUF_SIZE = 1 };
 ;   typedef int InnerTypedef;
 ;   enum { InnerEnumerator = 2 };
 ;   struct InnerStruct { };
 ; };

llvm/test/DebugInfo/COFF/pieces.ll

 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc < %s -filetype=obj | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
 
 ; Compile with -O1 as C
 
 ; struct IntPair { int x, y; };
 ; struct PadRight { long a; int b; };
 ; struct PadLeft { int a; long b; };
 ; struct Nested { struct PadLeft a[2]; };
 ;

llvm/test/DebugInfo/COFF/purge-typedef-udts.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj - --codeview | FileCheck %s
 source_filename = "test/DebugInfo/COFF/purge-typedef-udts.ll"
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc19.11.25506"
 
 ; C++ source to regenerate:
 ; $ cat t.cpp
 ; struct Foo;
 ; struct Bar {

llvm/test/DebugInfo/COFF/register-variables.ll

 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc < %s -filetype=obj | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
 
 ; Generated from:
 ; volatile int x;
 ; int getint(void);
 ; void putint(int);
 ; static inline int inlineinc(int a) {
 ;   int b = a + 1;
 ;   ++x;

llvm/test/DebugInfo/COFF/retained-types.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; This test checks that types which are used in expressions, but for which
 ; there are no variables, known as retained types, get emitted.
 
 ; C++ source to regenerate:
 ; $ cat /tmp/a.cc
 ; struct S { int x; };
 ; int f(void *p) {

llvm/test/DebugInfo/COFF/scopes.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; Check that we keep namespace scopes around the same way MSVC does.
 ; We do function scopes slightly differently, but everything should be alright.
 
 ; C++ source to regenerate:
 ; namespace foo {
 ; namespace bar {
 ; void baz() {

llvm/test/DebugInfo/COFF/simple.ll

 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 -O0 < %s | FileCheck --check-prefix=X86 %s
 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32-itanium -O0 < %s | FileCheck --check-prefix=X86 %s
 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32-gnu -O0 < %s | FileCheck --check-prefix=X86 %s
+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 -o - -O0 < %s -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ32 %s
 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 -o - -O0 < %s | llvm-mc -triple=i686-pc-win32 -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ32 %s
+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32-itanium -o - -O0 < %s -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ32 %s
 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32-itanium -o - -O0 < %s | llvm-mc -triple=i686-pc-win32 -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ32 %s
+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32-gnu -o - -O0 < %s -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ32 %s
 ; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32-gnu -o - -O0 < %s | llvm-mc -triple=i686-pc-win32 -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ32 %s
 ; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32 -O0 < %s | FileCheck --check-prefix=X64 %s
 ; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32-itanium -O0 < %s | FileCheck --check-prefix=X64 %s
 ; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32-gnu -O0 < %s | FileCheck --check-prefix=X64 %s
+; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32 -o - -O0 < %s -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ64 %s
 ; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32 -o - -O0 < %s | llvm-mc -triple=x86_64-pc-win32 -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ64 %s
+; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32-itanium -o - -O0 < %s -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ64 %s
 ; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32-itanium -o - -O0 < %s | llvm-mc -triple=x86_64-pc-win32 -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ64 %s
+; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32-gnu -o - -O0 < %s -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ64 %s
 ; RUN: llc -mcpu=core2 -mtriple=x86_64-pc-win32-gnu -o - -O0 < %s | llvm-mc -triple=x86_64-pc-win32 -filetype=obj | llvm-readobj -S --sr --codeview --section-symbols | FileCheck --check-prefix=OBJ64 %s
 
 ; This LL file was generated by running clang on the following code:
 ; D:\test.c:
 ; 1 void g(void);
 ; 2
 ; 3 void f(void) {
 ; 4   g();

llvm/test/DebugInfo/COFF/static-methods.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; Check for the appropriate MethodKind below.
 
 ; C++ source used to generate IR:
 ; $ cat t.cpp
 ; struct A {
 ;   static void f();
 ;   void g();

llvm/test/DebugInfo/COFF/swift.ll

 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc -filetype=obj < %s | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
 
 ; ASM:      .short  4412                    # Record kind: S_COMPILE3
 ; ASM-NEXT: .long   83                      # Flags and language
 ; ASM-NEXT: .short  208                     # CPUType
 
 ; OBJ-LABEL: Compile3Sym {
 ; OBJ-NEXT:    Kind: S_COMPILE3 (0x113C)
 ; OBJ-NEXT:    Language: Swift (0x53)

llvm/test/DebugInfo/COFF/thunk.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj - --codeview | FileCheck %s
 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: opt -S -debugger-tune=lldb %s | FileCheck -check-prefix=OPT %s
 ;
 ; -- "thunk.cpp" begin --------------------------------------------------------
 ; class A { public: virtual bool MyMethod() { return true; } }; 
 ; class B { public: virtual bool MyMethod() { return true; } }; 
 ; class C : public virtual A, public virtual B { 
 ; public: 

llvm/test/DebugInfo/COFF/type-quals.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; $ cat m.cpp
 ; union Union {
 ;   int * __restrict x_member;
 ;   float * __restrict y_member;
 ;   int* volatile __restrict m_volatile;
 ; };

llvm/test/DebugInfo/COFF/typedef.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; CHECK: CodeViewDebugInfo [
 ; CHECK:   Subsection [
 ; CHECK:     LocalSym {
 ; CHECK:       Type: wchar_t (0x71)
 ; CHECK:       Flags [ (0x0)
 ; CHECK:       ]
 ; CHECK:       VarName: foo

llvm/test/DebugInfo/COFF/types-array-advanced.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; $ cat t.cpp
 ; char multi_dim_arr[2][5][7];
 ;
 ; struct incomplete_struct(*p_incomplete_struct_arr)[3];
 ; struct incomplete_struct {
 ;   int s1;

llvm/test/DebugInfo/COFF/types-array-unsized.ll

 ; RUN: llc -filetype=obj < %s | llvm-readobj --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj --codeview | FileCheck %s
 
 ; We should emit two array types: one used to describe the static data member,
 ; and the other used by the S_GDATA32 for the definition.
 
 ; C++ source:
 ; struct Foo {
 ;   static const char str[];
 ; };

llvm/test/DebugInfo/COFF/types-array.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; $ cat t.cpp
 ; void usevars(int, ...);
 ; void f() {
 ;   int a[5] = {9, 4, 5, 4, 2};
 ;   usevars(a[0], a);
 ; }

llvm/test/DebugInfo/COFF/types-basic.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 
 ; C++ source to regenerate:
 ; $ cat t.cpp
 ; struct A {
 ;   int a;
 ;   void f();
 ; };
 ; void usevars(int, ...);

 ; CHECK:       ]
 ; CHECK:       VarName: c32
 ; CHECK:     }
 ; CHECK:     ProcEnd {
 ; CHECK:     }
 ; CHECK:   ]
 ; CHECK: ]
 
+; ASM: # ArgList (0x1000) {
+; ASM: #   TypeLeafKind: LF_ARGLIST (0x1201)
+; ASM: #   NumArgs: 3
+; ASM: #   Arguments [
+; ASM: #     ArgType: float (0x40)
+; ASM: #     ArgType: double (0x41)
+; ASM: #     ArgType: __int64 (0x13)
+; ASM: #   ]
+; ASM: # }
+; ASM: .short 14
+; ASM: .short 4104
+; ASM: .long  3
+; ASM: .byte  0
+; ASM: .byte  0
+; ASM: .short 3
+; ASM: .long  4096
+; ASM: # Procedure (0x1001) {
+; ASM: #   TypeLeafKind: LF_PROCEDURE (0x1008)
+; ASM: #   ReturnType: void (0x3)
+; ASM: #   CallingConvention: NearC (0x0)
+; ASM: #   FunctionOptions [ (0x0)
+; ASM: #   ]
+; ASM: #   NumParameters: 3
+; ASM: #   ArgListType: (float, double, __int64) (0x1000)
+; ASM: # }
+; ASM: .short 14
+; ASM: .short 5633
+; ASM: .long  0
+; ASM: .long  4097
+; ASM: .asciz "f"
+; ASM: .byte  242
+; ASM: .byte  241
+; ASM: # FuncId (0x1002) {
+; ASM: #   TypeLeafKind: LF_FUNC_ID (0x1601)
+; ASM: #   ParentScope: 0x0
+; ASM: #   FunctionType: void (float, double, __int64) (0x1001)
+; ASM: #   Name: f
+; ASM: # }
+; ASM: .short 10
+; ASM: .short 4097
+; ASM: .long  116
+; ASM: .short 1
+; ASM: .byte  242
+; ASM: .byte  241
+; ASM: # Modifier (0x1003) {
+; ASM: #   TypeLeafKind: LF_MODIFIER (0x1001)
+; ASM: #   ModifiedType: int (0x74)
+; ASM: #   Modifiers [ (0x1)
+; ASM: #     Const (0x1)
+; ASM: #   ]
+; ASM: # }
+; ASM: .short 10
+; ASM: .short 4098
+; ASM: .long  4099
+; ASM: .long  65548
+; ASM: # Pointer (0x1004) {
+; ASM: #   TypeLeafKind: LF_POINTER (0x1002)
+; ASM: #   PointeeType: const int (0x1003)
+; ASM: #   PtrType: Near64 (0xC)
+; ASM: #   PtrMode: Pointer (0x0)
+; ASM: #   IsFlat: 0
+; ASM: #   IsConst: 0
+; ASM: #   IsVolatile: 0
+; ASM: #   IsUnaligned: 0
+; ASM: #   IsRestrict: 0
+; ASM: #   IsThisPtr&: 0
+; ASM: #   IsThisPtr&&: 0
+; ASM: #   SizeOf: 8
+; ASM: # }
+; ASM: .short 22
+; ASM: .short 5381
+; ASM: .short 0
+; ASM: .short 128
+; ASM: .long  0
+; ASM: .long  0
+; ASM: .long  0
+; ASM: .short 0
+; ASM: .asciz "A"
+; ASM: # Struct (0x1005) {
+; ASM: #   TypeLeafKind: LF_STRUCTURE (0x1505)
+; ASM: #   MemberCount: 0
+; ASM: #   Properties [ (0x80)
+; ASM: #     ForwardReference (0x80)
+; ASM: #   ]
+; ASM: #   FieldList: 0x0
+; ASM: #   DerivedFrom: 0x0
+; ASM: #   VShape: 0x0
+; ASM: #   SizeOf: 0
+; ASM: #   Name: A
+; ASM: # }
+; ASM: .short 18
+; ASM: .short 4098
+; ASM: .long  116
+; ASM: .long  32844
+; ASM: .long  4101
+; ASM: .short 4
+; ASM: .byte  242
+; ASM: .byte  241
+; ASM: # Pointer (0x1006) {
+; ASM: #   TypeLeafKind: LF_POINTER (0x1002)
+; ASM: #   PointeeType: int (0x74)
+; ASM: #   PtrType: Near64 (0xC)
+; ASM: #   PtrMode: PointerToDataMember (0x2)
+; ASM: #   IsFlat: 0
+; ASM: #   IsConst: 0
+; ASM: #   IsVolatile: 0
+; ASM: #   IsUnaligned: 0
+; ASM: #   IsRestrict: 0
+; ASM: #   IsThisPtr&: 0
+; ASM: #   IsThisPtr&&: 0
+; ASM: #   SizeOf: 4
+; ASM: #   ClassType: A (0x1005)
+; ASM: #   Representation: GeneralData (0x4)
+; ASM: # }
+; ASM: .short 10
+; ASM: .short 4098
+; ASM: .long  4101
+; ASM: .long  66572
+; ASM: # Pointer (0x1007) {
+; ASM: #   TypeLeafKind: LF_POINTER (0x1002)
+; ASM: #   PointeeType: A (0x1005)
+; ASM: #   PtrType: Near64 (0xC)
+; ASM: #   PtrMode: Pointer (0x0)
+; ASM: #   IsFlat: 0
+; ASM: #   IsConst: 1
+; ASM: #   IsVolatile: 0
+; ASM: #   IsUnaligned: 0
+; ASM: #   IsRestrict: 0
+; ASM: #   IsThisPtr&: 0
+; ASM: #   IsThisPtr&&: 0
+; ASM: #   SizeOf: 8
+; ASM: # }
+; ASM: .short 6
+; ASM: .short 4609
+; ASM: .long  0
+; ASM: # ArgList (0x1008) {
+; ASM: #   TypeLeafKind: LF_ARGLIST (0x1201)
+; ASM: #   NumArgs: 0
+; ASM: #   Arguments [
+; ASM: #   ]
+; ASM: # }
+; ASM: .short 26
+; ASM: .short 4105
+; ASM: .long  3
+; ASM: .long  4101
+; ASM: .long  4103
+; ASM: .byte  0
+; ASM: .byte  0
+; ASM: .short 0
+; ASM: .long  4104
+; ASM: .long  0
+; ASM: # MemberFunction (0x1009) {
+; ASM: #   TypeLeafKind: LF_MFUNCTION (0x1009)
+; ASM: #   ReturnType: void (0x3)
+; ASM: #   ClassType: A (0x1005)
+; ASM: #   ThisType: A* const (0x1007)
+; ASM: #   CallingConvention: NearC (0x0)
+; ASM: #   FunctionOptions [ (0x0)
+; ASM: #   ]
+; ASM: #   NumParameters: 0
+; ASM: #   ArgListType: () (0x1008)
+; ASM: #   ThisAdjustment: 0
+; ASM: # }
+; ASM: .short 30
+; ASM: .short 4611
+; ASM: .ascii "\r\025\003\000t\000\000\000\000\000a\000\021\025\003\000\t\020\000\000A::f\000\363\362\361"
+; ASM: # FieldList (0x100A) {
+; ASM: #   TypeLeafKind: LF_FIELDLIST (0x1203)
+; ASM: #   DataMember {
+; ASM: #     TypeLeafKind: LF_MEMBER (0x150D)
+; ASM: #     AccessSpecifier: Public (0x3)
+; ASM: #     Type: int (0x74)
+; ASM: #     FieldOffset: 0x0
+; ASM: #     Name: a
+; ASM: #   }
+; ASM: #   OneMethod {
+; ASM: #     TypeLeafKind: LF_ONEMETHOD (0x1511)
+; ASM: #     AccessSpecifier: Public (0x3)
+; ASM: #     Type: void A::() (0x1009)
+; ASM: #     Name: A::f
+; ASM: #   }
+; ASM: # }
+; ASM: .short 22
+; ASM: .short 5381
+; ASM: .short 2
+; ASM: .short 0
+; ASM: .long  4106
+; ASM: .long  0
+; ASM: .long  0
+; ASM: .short 4
+; ASM: .asciz "A"
+; ASM: # Struct (0x100B) {
+; ASM: #   TypeLeafKind: LF_STRUCTURE (0x1505)
+; ASM: #   MemberCount: 2
+; ASM: #   Properties [ (0x0)
+; ASM: #   ]
+; ASM: #   FieldList: <field list> (0x100A)
+; ASM: #   DerivedFrom: 0x0
+; ASM: #   VShape: 0x0
+; ASM: #   SizeOf: 4
+; ASM: #   Name: A
+; ASM: # }
+; ASM: .short 30
+; ASM: .short 5637
+; ASM: .long  0
+; ASM: .asciz "D:\\src\\llvm\\build\\t.cpp"
+; ASM: # StringId (0x100C) {
+; ASM: #   TypeLeafKind: LF_STRING_ID (0x1605)
+; ASM: #   Id: 0x0
+; ASM: #   StringData: D:\src\llvm\build\t.cpp
+; ASM: # }
+; ASM: .short 14
+; ASM: .short 5638
+; ASM: .long  4107
+; ASM: .long  4108
+; ASM: .long  1
+; ASM: # UdtSourceLine (0x100D) {
+; ASM: #   TypeLeafKind: LF_UDT_SRC_LINE (0x1606)
+; ASM: #   UDT: A (0x100B)
+; ASM: #   SourceFile: D:\src\llvm\build\t.cpp (0x100C)
+; ASM: #   LineNumber: 1
+; ASM: # }
+; ASM: .short 18
+; ASM: .short 4098
+; ASM: .long  4105
+; ASM: .long  65644
+; ASM: .long  4101
+; ASM: .short 8
+; ASM: .byte  242
+; ASM: .byte  241
+; ASM: # Pointer (0x100E) {
+; ASM: #   TypeLeafKind: LF_POINTER (0x1002)
+; ASM: #   PointeeType: void A::() (0x1009)
+; ASM: #   PtrType: Near64 (0xC)
+; ASM: #   PtrMode: PointerToMemberFunction (0x3)
+; ASM: #   IsFlat: 0
+; ASM: #   IsConst: 0
+; ASM: #   IsVolatile: 0
+; ASM: #   IsUnaligned: 0
+; ASM: #   IsRestrict: 0
+; ASM: #   IsThisPtr&: 0
+; ASM: #   IsThisPtr&&: 0
+; ASM: #   SizeOf: 8
+; ASM: #   ClassType: A (0x1005)
+; ASM: #   Representation: GeneralFunction (0x8)
+; ASM: # }
+; ASM: .short 10
+; ASM: .short 4097
+; ASM: .long  3
+; ASM: .short 1
+; ASM: .byte  242
+; ASM: .byte  241
+; ASM: # Modifier (0x100F) {
+; ASM: #   TypeLeafKind: LF_MODIFIER (0x1001)
+; ASM: #   ModifiedType: void (0x3)
+; ASM: #   Modifiers [ (0x1)
+; ASM: #     Const (0x1)
+; ASM: #   ]
+; ASM: # }
+; ASM: .short 10
+; ASM: .short 4098
+; ASM: .long  4111
+; ASM: .long  65548
+; ASM: # Pointer (0x1010) {
+; ASM: #   TypeLeafKind: LF_POINTER (0x1002)
+; ASM: #   PointeeType: const void (0x100F)
+; ASM: #   PtrType: Near64 (0xC)
+; ASM: #   PtrMode: Pointer (0x0)
+; ASM: #   IsFlat: 0
+; ASM: #   IsConst: 0
+; ASM: #   IsVolatile: 0
+; ASM: #   IsUnaligned: 0
+; ASM: #   IsRestrict: 0
+; ASM: #   IsThisPtr&: 0
+; ASM: #   IsThisPtr&&: 0
+; ASM: #   SizeOf: 8
+; ASM: # }
+; ASM: .short 14
+; ASM: .short 4104
+; ASM: .long  3
+; ASM: .byte  0
+; ASM: .byte  0
+; ASM: .short 0
+; ASM: .long  4104
+; ASM: # Procedure (0x1011) {
+; ASM: #   TypeLeafKind: LF_PROCEDURE (0x1008)
+; ASM: #   ReturnType: void (0x3)
+; ASM: #   CallingConvention: NearC (0x0)
+; ASM: #   FunctionOptions [ (0x0)
+; ASM: #   ]
+; ASM: #   NumParameters: 0
+; ASM: #   ArgListType: () (0x1008)
+; ASM: # }
+; ASM: .short 22
+; ASM: .short 5633
+; ASM: .long  0
+; ASM: .long  4113
+; ASM: .asciz "CharTypes"
+; ASM: .byte  242
+; ASM: .byte  241
+; ASM: # FuncId (0x1012) {
+; ASM: #   TypeLeafKind: LF_FUNC_ID (0x1601)
+; ASM: #   ParentScope: 0x0
+; ASM: #   FunctionType: void () (0x1011)
+; ASM: #   Name: CharTypes
+; ASM: # }
+; ASM: .short 26
+; ASM: .short 5637
+; ASM: .long  0
+; ASM: .asciz "D:\\src\\llvm\\build"
+; ASM: .byte  242
+; ASM: .byte  241
+; ASM: # StringId (0x1013) {
+; ASM: #   TypeLeafKind: LF_STRING_ID (0x1605)
+; ASM: #   Id: 0x0
+; ASM: #   StringData: D:\src\llvm\build
+; ASM: # }
+; ASM: .short 14
+; ASM: .short 5637
+; ASM: .long  0
+; ASM: .asciz "t.cpp"
+; ASM: .byte  242
+; ASM: .byte  241
+; ASM: # StringId (0x1014) {
+; ASM: #   TypeLeafKind: LF_STRING_ID (0x1605)
+; ASM: #   Id: 0x0
+; ASM: #   StringData: t.cpp
+; ASM: # }
+; ASM: .short 26
+; ASM: .short 5635
+; ASM: .short 5
+; ASM: .long  4115
+; ASM: .long  0
+; ASM: .long  4116
+; ASM: .long  0
+; ASM: .long  0
+; ASM: .byte  242
+; ASM: .byte  241
+; ASM: # BuildInfo (0x1015) {
+; ASM: #   TypeLeafKind: LF_BUILDINFO (0x1603)
+; ASM: #   NumArgs: 5
+; ASM: #   Arguments [
+; ASM: #     ArgType: D:\src\llvm\build (0x1013)
+; ASM: #     ArgType: 0x0
+; ASM: #     ArgType: t.cpp (0x1014)
+; ASM: #     ArgType: 0x0
+; ASM: #     ArgType: 0x0
+; ASM: #   ]
+; ASM: # }
+
 ; ModuleID = 't.cpp'
 source_filename = "t.cpp"
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc19.0.23918"
 
 %struct.A = type { i32 }
 
 ; Function Attrs: uwtable

llvm/test/DebugInfo/COFF/types-calling-conv.ll

 ; RUN: llc < %s -filetype=obj -o - | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s -o - | llvm-mc -filetype=obj --triple=i386-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; $ cat t.cpp
 ; struct A {
 ;   void thiscallcc();
 ; };
 ; void A::thiscallcc() {}
 ; void cdeclcc() {}

llvm/test/DebugInfo/COFF/types-cvarargs.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; $ cat t.cpp
 ; typedef void (*FuncTypedef)(int, float, ...);
 ; FuncTypedef funcVar;
 ; namespace MemberTest {
 ;   class A {
 ;   public:

llvm/test/DebugInfo/COFF/types-data-members.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; $ cat t.cpp
 ; struct Struct {
 ;   int s1;
 ;   int s2;
 ;   int s3;
 ;   static const int sdm = 3;

llvm/test/DebugInfo/COFF/types-empty-member-fn.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; ModuleID = 'foo.3a1fbbbh-cgu.0'
 source_filename = "foo.3a1fbbbh-cgu.0"
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 ; Rust source to regenerate:
 ; $ cat foo.rs

llvm/test/DebugInfo/COFF/types-method-ref-qualifiers.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; struct A {
 ;   int NoRefQual();
 ;
 ;   int RefQual() &;
 ;   int RefQual() &&;
 ;

llvm/test/DebugInfo/COFF/types-nested-class.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; $ cat hello.cpp
 ; struct A {
 ;   struct Nested {};
 ; } a;
 ; $ clang hello.cpp -S -emit-llvm -g -gcodeview -o t.ll
 

llvm/test/DebugInfo/COFF/types-non-virtual-methods.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; $ cat t.cpp
 ; struct A {
 ;   void f_default_public();
 ; private:
 ;   void f_private();
 ; protected:

llvm/test/DebugInfo/COFF/types-ptr-to-member.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; $ cat t.cpp
 ; struct A { int a; };
 ; struct B { int b; };
 ; struct C : A, B { int c; };
 ; struct D : virtual C { int d; };
 ; struct E;

llvm/test/DebugInfo/COFF/types-recursive-struct.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; This test ensures that circular type references through pointer types don't
 ; cause infinite recursion. It also tests that we always refer to the forward
 ; declaration type index in field lists and pointer types, which is consistent
 ; with what MSVC does. It ensures that these records get merged when merging
 ; streams even if the complete record types differ slightly due to ODR
 ; violations, i.e. methods that only exist ifndef NDEBUG.
 

llvm/test/DebugInfo/COFF/types-std-nullptr-t.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; $ cat foo.cpp
 ; decltype(nullptr) NullPtr = nullptr;
 ; $ clang hello.cpp -S -emit-llvm -g -gcodeview -o t.ll
 
 ; CHECK: CodeViewDebugInfo [
 ; CHECK:   Subsection [

llvm/test/DebugInfo/COFF/udts.ll

 ; RUN: llc < %s -filetype=obj > %t.obj
 ; RUN: llvm-readobj --codeview %t.obj | FileCheck --check-prefix=READOBJ %s
 ; RUN: llvm-pdbutil dump -symbols %t.obj | FileCheck --check-prefix=PDBUTIL %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj --codeview | FileCheck --check-prefix=READOBJ %s
 
 ; C++ to regenerate:
 ; $ clang -g -gcodeview -m64 -S -emit-llvm t.cpp
 ; $ cat t.cpp
 ; void f() {
 ;   typedef int FOO;
 ;   FOO f;
 ; }

llvm/test/DebugInfo/COFF/unnamed.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 ;
 ; Verify CodeView emission does not emit forward references for unnamed
 ; structs/unions.  If a forward reference is emitted for an unnamed composite
 ; type then Visual Studio will not be able to display the value.
 ;
 ;   Previous values displayed by Visual Studio:
 ;      local.unnamed_struct    {...}
 ;      local.unnamed_union     {...}

llvm/test/DebugInfo/COFF/vframe-csr.ll

 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc -filetype=obj < %s | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i386-windows | llvm-readobj --codeview | FileCheck %s --check-prefix=OBJ
 
 ; PR38857
 
 ; This test case is identical to the fpo-realign-vframe.ll test, except it uses
 ; two callee-saved registers.
 
 ; Match the prologue for the .cv_fpo* directives.
 ; ASM-LABEL: _realign_with_csrs:

llvm/test/DebugInfo/COFF/vframe-fpo.ll

 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc < %s -filetype=obj | llvm-readobj --codeview | FileCheck %s --check-prefix=CODEVIEW
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=i386-windows | llvm-readobj --codeview | FileCheck %s --check-prefix=CODEVIEW
 
 ; This test checks that for 32-bit x86 we use VFRAME and
 ; S_DEFRANGE_FRAMEPOINTER_REL with the right offsets. The test has two function
 ; calls with different stack depths, which makes it impossible to correctly
 ; describe locals in memory as being ESP-relative.
 
 ; The following source can be used with a debugger to check that locals are
 ; displayed correctly:

llvm/test/DebugInfo/COFF/vftables.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; struct A {
 ;   virtual void f();
 ;   virtual void g();
 ;   int a = 0;
 ; };
 ; struct B {

llvm/test/DebugInfo/COFF/virtual-method-kinds.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; Check for the appropriate MethodKind below.
 
 ; C++ source used to generate IR:
 ; $ cat t.cpp
 ; struct A {
 ;   virtual void f();   // IntroducingVirtual
 ;   virtual void g() = 0; // PureIntroducingVirtual

llvm/test/DebugInfo/COFF/virtual-methods.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source used to generate IR:
 ; $ cat t.cpp
 ; struct A {
 ;   virtual int f();
 ; };
 ; struct B {
 ;   virtual int g() = 0;

llvm/test/DebugInfo/COFF/vtable-optzn-array.ll

 ; RUN: llc < %s -filetype=obj -o - | llvm-readobj - --codeview | FileCheck %s
+; RUN: llc < %s -o - | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; We used to crash on this input because UnicodeString is a forward declaration
 ; with no size. Our array type logic wanted to assert the size of the elements
 ; times the length matched the overall size.
 
 ; C++ source to regenerate:
 ; struct UnicodeString;
 ; struct GetFwdDecl {