[CodeView] Saturate values bigger than supported by APInt.

[mizvekov]

Summary

This fixes an assert firing when compiling code which involves 128 bit
integrals.

This would trigger runtime checks similar to this:

Assertion failed: getMinSignedBits() <= 64 && "Too many bits for int64_t", file llvm/include/llvm/ADT/APInt.h, line 1646

To get around this, we just saturate those big values.

[MaskRay]

(I don't know the mechanism so will defer to rnk.)

[rnk]

Please add a test case for this.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

3167

This avoids the crash, but I believe it will produce corrupt codeview records. I think it would be preferable to saturate the APSInt to the maximum representable encoded integer value in CodeViewRecordIO in the streaming and writing cases. There is prior art for this: long strings are truncated, for example.

[mizvekov]

• Fixes more issues.
• Add test cases.
• Add some FIXME notes.

[mizvekov]

• Really git add the test case this time.

[mizvekov]

.

[rnk]

I decided it would be faster and more convenient to respond in the form of a code review for clang, so here it is: D106585

Assuming that goes through, go ahead and rebase onto that after it lands.

clang/test/CodeGenCXX/debug-info-codeview-int128.cpp

1 ↗

(On Diff #360648)

FWIW this actually isn't codeview specific. The existing code crashes if you compile for DWARF too:
https://gcc.godbolt.org/z/3ox8c87Y4

To channel @dblaikie , this test should be split up: ensure that clang produces the right LLVM IR, then add a codeview specific LLVM IR test case. We prefer to test the smallest testable unit.

llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp

201

You can use Value.isSingleWord() for a simpler condition.

205

This can be Value.getLimitedValue().

279

I think this particular method is uncovered because of a separate bug. We always consider enumerators to be unsigned:
https://github.com/llvm/llvm-project/blob/main/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp#L2120

I'm not sure if that's a bug or if it is intended, but that's why this is relatively uncovered.

llvm/lib/IR/DIBuilder.cpp

249

Since DIEnumerator actually stores an APInt, can you add an overload that accepts an APSInt and call that from clang instead? The implementation will have to decompose the sign bit and slice out the APInt portion, but that seems like a better way of handling this.

I noticed the APInt change to DIEnumerator is new as of D62475, so April 2020. +@MaskRay @LemonBoy

[mizvekov]

• rebase on top of D106585
• Reimplement test based on IR

[mizvekov]

• Expose and use APInt::isSingleWord.
• Use ApInt::getLimitedValue.

[mizvekov]

.

[rnk]

lgtm with minor comment adjustments

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

3167

I don't think we need a TODO here. If Microsoft ever adds an encoding for large integers, the code change will be elsewhere, and in the process of testing, this size 10 array is bounds checked during the writing process, so we don't need this comment to remind us to change this code.

llvm/test/DebugInfo/COFF/integer-128.ll

23

(no AI) I see, in the future we should make this use the "streaming" output style so this comes out as .short .quad directives.

[mizvekov]

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

3167

I agree the comment does not belong here, but I think we have encodings already, both for the value and the type.

CodeViewTypes.def:

CV_TYPE(LF_OCTWORD, 0x8017)
CV_TYPE(LF_UOCTWORD, 0x8018)

CodeViewDebug.cpp:

case dwarf::DW_ATE_signed:
  switch (ByteSize) {
  case 1:  STK = SimpleTypeKind::SignedCharacter; break;
  case 2:  STK = SimpleTypeKind::Int16Short;      break;
  case 4:  STK = SimpleTypeKind::Int32;           break;
  case 8:  STK = SimpleTypeKind::Int64Quad;       break;
  case 16: STK = SimpleTypeKind::Int128Oct;       break; // <-------
  }

Unless it would be risky to try to use them, if for example the Microsoft tooling would have trouble digesting it?

FWIW I would have considered adding this support, but then I found all those other problems, and time is a bit short until release branching.

[mizvekov]

I received this report from one of the bots: https://lab.llvm.org/buildbot/#/builders/5/builds/9633/steps/13/logs/stdio

`
FAIL: Clang :: CodeGenCXX/debug-info-enum-i128.cpp (5356 of 77963)
******************** TEST 'Clang :: CodeGenCXX/debug-info-enum-i128.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   /b/sanitizer-x86_64-linux-fast/build/llvm_build_asan/bin/clang -cc1 -internal-isystem /b/sanitizer-x86_64-linux-fast/build/llvm_build_asan/lib/clang/13.0.0/include -nostdsysteminc /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/test/CodeGenCXX/debug-info-enum-i128.cpp -triple x86_64-windows-msvc -gcodeview -debug-info-kind=limited -emit-llvm -o - | /b/sanitizer-x86_64-linux-fast/build/llvm_build_asan/bin/FileCheck /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/test/CodeGenCXX/debug-info-enum-i128.cpp
: 'RUN: at line 2';   /b/sanitizer-x86_64-linux-fast/build/llvm_build_asan/bin/clang -cc1 -internal-isystem /b/sanitizer-x86_64-linux-fast/build/llvm_build_asan/lib/clang/13.0.0/include -nostdsysteminc /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/test/CodeGenCXX/debug-info-enum-i128.cpp -triple x86_64-linux-gnu -debug-info-kind=limited -emit-llvm -o - | /b/sanitizer-x86_64-linux-fast/build/llvm_build_asan/bin/FileCheck /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/test/CodeGenCXX/debug-info-enum-i128.cpp
--
Exit Code: 1
Command Output (stderr):
--
=================================================================
==22208==ERROR: LeakSanitizer: detected memory leaks
Direct leak of 16 byte(s) in 1 object(s) allocated from:
    #0 0x72240dd in operator new[](unsigned long) /b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/asan_new_delete.cpp:98:3
    #1 0xe21510a in getMemory /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/Support/APInt.cpp:46:10
    #2 0xe21510a in llvm::APInt::initSlowCase(llvm::APInt const&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/Support/APInt.cpp:87:12
    #3 0x164a460b in APInt /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/include/llvm/ADT/APInt.h:321:7
    #4 0x164a460b in APSInt /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/include/llvm/ADT/APSInt.h:22:22
    #5 0x164a460b in EnumConstantDecl /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/include/clang/AST/Decl.h:3048:62
    #6 0x164a460b in clang::EnumConstantDecl::Create(clang::ASTContext&, clang::EnumDecl*, clang::SourceLocation, clang::IdentifierInfo*, clang::QualType, clang::Expr*, llvm::APSInt const&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/AST/Decl.cpp:4916:22
    #7 0x14605da3 in clang::Sema::CheckEnumConstant(clang::EnumDecl*, clang::EnumConstantDecl*, clang::SourceLocation, clang::IdentifierInfo*, clang::Expr*) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Sema/SemaDecl.cpp:17905:10
    #8 0x14607d80 in clang::Sema::ActOnEnumConstant(clang::Scope*, clang::Decl*, clang::Decl*, clang::SourceLocation, clang::IdentifierInfo*, clang::ParsedAttributesView const&, clang::SourceLocation, clang::Expr*) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Sema/SemaDecl.cpp:17970:5
    #9 0x13ead361 in clang::Parser::ParseEnumBody(clang::SourceLocation, clang::Decl*) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Parse/ParseDecl.cpp:4855:35
    #10 0x13e9f97b in clang::Parser::ParseEnumSpecifier(clang::SourceLocation, clang::DeclSpec&, clang::Parser::ParsedTemplateInfo const&, clang::AccessSpecifier, clang::Parser::DeclSpecContext) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Parse/ParseDecl.cpp:4774:5
    #11 0x13e7e7e3 in clang::Parser::ParseDeclarationSpecifiers(clang::DeclSpec&, clang::Parser::ParsedTemplateInfo const&, clang::AccessSpecifier, clang::Parser::DeclSpecContext, clang::Parser::LateParsedAttrList*) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Parse/ParseDecl.cpp:3999:7
    #12 0x13d47ec6 in clang::Parser::ParseDeclOrFunctionDefInternal(clang::ParsedAttributesWithRange&, clang::ParsingDeclSpec&, clang::AccessSpecifier) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Parse/Parser.cpp:1045:3
    #13 0x13d47183 in clang::Parser::ParseDeclarationOrFunctionDefinition(clang::ParsedAttributesWithRange&, clang::ParsingDeclSpec*, clang::AccessSpecifier) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Parse/Parser.cpp:1153:12
    #14 0x13d4305f in clang::Parser::ParseExternalDeclaration(clang::ParsedAttributesWithRange&, clang::ParsingDeclSpec*) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Parse/Parser.cpp:975:12
    #15 0x13d3bcb8 in clang::Parser::ParseTopLevelDecl(clang::OpaquePtr<clang::DeclGroupRef>&, bool) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Parse/Parser.cpp:720:12
    #16 0x13d22d2c in clang::ParseAST(clang::Sema&, bool, bool) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Parse/ParseAST.cpp:158:20
    #17 0x10592b4c in clang::CodeGenAction::ExecuteAction() /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/CodeGen/CodeGenAction.cpp:1044:30
    #18 0x102ed574 in clang::FrontendAction::Execute() /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Frontend/FrontendAction.cpp:951:8
    #19 0x101044b0 in clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Frontend/CompilerInstance.cpp:974:33
    #20 0x105808e0 in clang::ExecuteCompilerInvocation(clang::CompilerInstance*) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp:278:25
    #21 0x7237834 in cc1_main(llvm::ArrayRef<char const*>, char const*, void*) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/tools/driver/cc1_main.cpp:246:15
    #22 0x723059f in ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/tools/driver/driver.cpp:338:12
    #23 0x722e6f4 in main /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/tools/driver/driver.cpp:415:12
    #24 0x7fc40b7e809a in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2409a)
SUMMARY: AddressSanitizer: 32 byte(s) leaked in 2 allocation(s).
`

The error is happening on the test created for D106585 though.

[rnk]

Yes, I filed https://bugs.llvm.org/show_bug.cgi?id=51221 for it. I plan to disable the test under asan for now.

[mizvekov]

In D105320#2905887, @rnk wrote:

Yes, I filed https://bugs.llvm.org/show_bug.cgi?id=51221 for it. I plan to disable the test under asan for now.

:-(

Thanks for taking care of it though!

llvm/include/llvm/ADT/APInt.h

private:
   /// Fast internal constructor
   ///
   /// This constructor is used only internally for speed of construction of
   /// temporaries. It is unsafe for general use so it is not public.
   APInt(uint64_t *val, unsigned bits) : BitWidth(bits) {
     U.pVal = val;
   }
 
-  /// Determine if this APInt just has one word to store value.
-  ///
-  /// \returns true if the number of bits <= 64, false otherwise.
-  bool isSingleWord() const { return BitWidth <= APINT_BITS_PER_WORD; }
-
   /// Determine which word a bit is in.
   ///
   /// \returns the word position for the specified bit position.
   static unsigned whichWord(unsigned bitPosition) {
     return bitPosition / APINT_BITS_PER_WORD;
   }
 
   /// Determine which bit in a word a bit is in.
public:
   /// Used to insert APInt objects, or objects that contain APInt objects, into
   ///  FoldingSets.
   void Profile(FoldingSetNodeID &id) const;
 
   /// @}
   /// \name Value Tests
   /// @{
 
+  /// Determine if this APInt just has one word to store value.
+  ///
+  /// \returns true if the number of bits <= 64, false otherwise.
+  bool isSingleWord() const { return BitWidth <= APINT_BITS_PER_WORD; }
+
   /// Determine sign of this APInt.
   ///
   /// This tests the high bit of this APInt to determine if it is set.
   ///
   /// \returns true if this APInt is negative, false otherwise
   bool isNegative() const { return (*this)[BitWidth - 1]; }
 
   /// Determine if this APInt Value is non-negative (>= 0)

llvm/include/llvm/IR/DIBuilder.h

public:
     /// \param Parent     Macro file parent (could be nullptr).
     /// \param Line       Source line number where the macro file is included.
     /// \param File       File descriptor containing the name of the macro file.
     DIMacroFile *createTempMacroFile(DIMacroFile *Parent, unsigned Line,
                                      DIFile *File);
 
     /// Create a single enumerator value.
     DIEnumerator *createEnumerator(StringRef Name, APSInt Value);
-    DIEnumerator *createEnumerator(StringRef Name, int64_t Val,
+    DIEnumerator *createEnumerator(StringRef Name, uint64_t Val,
                                    bool IsUnsigned = false);
 
     /// Create a DWARF unspecified type.
     DIBasicType *createUnspecifiedType(StringRef Name);
 
     /// Create C++11 nullptr type.
     DIBasicType *createNullPtrType();
 

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h

class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   void emitDebugInfoForRetainedTypes();
 
   void emitDebugInfoForUDTs(
       const std::vector<std::pair<std::string, const DIType *>> &UDTs);
 
   void collectDebugInfoForGlobals();
   void emitDebugInfoForGlobals();
   void emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals);
+  void emitConstantSymbolRecord(const DIType *DTy, APSInt &Value,
+                                const std::string &QualifiedName);
   void emitDebugInfoForGlobal(const CVGlobalVariable &CVGV);
   void emitStaticConstMemberList();
 
   /// Opens a subsection of the given kind in a .debug$S codeview section.
   /// Returns an end label for use with endCVSubsection when the subsection is
   /// finished.
   MCSymbol *beginCVSubsection(codeview::DebugSubsectionKind Kind);
   void endCVSubsection(MCSymbol *EndLabel);

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

if (Ty->isForwardDecl()) {
     CO |= ClassOptions::ForwardReference;
   } else {
     ContinuationRecordBuilder ContinuationBuilder;
     ContinuationBuilder.begin(ContinuationRecordKind::FieldList);
     for (const DINode *Element : Ty->getElements()) {
       // We assume that the frontend provides all members in source declaration
       // order, which is what MSVC does.
       if (auto *Enumerator = dyn_cast_or_null<DIEnumerator>(Element)) {
+        // FIXME: Is it correct to always emit these as unsigned here?
         EnumeratorRecord ER(MemberAccess::Public,
                             APSInt(Enumerator->getValue(), true),
                             Enumerator->getName());
         ContinuationBuilder.writeMemberType(ER);
         EnumeratorCount++;
       }
     }
     FTI = TypeTable.insertRecord(ContinuationBuilder);

 // Emit each global variable in the specified array.
 void CodeViewDebug::emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals) {
   for (const CVGlobalVariable &CVGV : Globals) {
     // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions.
     emitDebugInfoForGlobal(CVGV);
   }
 }
 
-void CodeViewDebug::emitStaticConstMemberList() {
-  for (const DIDerivedType *DTy : StaticConstMembers) {
-    const DIScope *Scope = DTy->getScope();
-
-    APSInt Value;
-    if (const ConstantInt *CI =
-            dyn_cast_or_null<ConstantInt>(DTy->getConstant()))
-      Value = APSInt(CI->getValue(),
-                     DebugHandlerBase::isUnsignedDIType(DTy->getBaseType()));
-    else if (const ConstantFP *CFP =
-                 dyn_cast_or_null<ConstantFP>(DTy->getConstant()))
-      Value = APSInt(CFP->getValueAPF().bitcastToAPInt(), true);
-    else
-      llvm_unreachable("cannot emit a constant without a value");
-
-    std::string QualifiedName = getFullyQualifiedName(Scope, DTy->getName());
-
-    MCSymbol *SConstantEnd = beginSymbolRecord(SymbolKind::S_CONSTANT);
-    OS.AddComment("Type");
-    OS.emitInt32(getTypeIndex(DTy->getBaseType()).getIndex());
-    OS.AddComment("Value");
+void CodeViewDebug::emitConstantSymbolRecord(const DIType *DTy, APSInt &Value,
+                                             const std::string &QualifiedName) {
+  OS.emitInt32(getTypeIndex(DTy).getIndex());
+
 
-    // Encoded integers shouldn't need more than 10 bytes.
-    uint8_t Data[10];
-    BinaryStreamWriter Writer(Data, llvm::support::endianness::little);
-    CodeViewRecordIO IO(Writer);
-    cantFail(IO.mapEncodedInteger(Value));
-    StringRef SRef((char *)Data, Writer.getOffset());
-    OS.emitBinaryData(SRef);
 
-    OS.AddComment("Name");
-    emitNullTerminatedSymbolName(OS, QualifiedName);
-    endSymbolRecord(SConstantEnd);
-  }
+
+void CodeViewDebug::emitStaticConstMemberList() {
+  for (const DIDerivedType *DTy : StaticConstMembers) {
+    const DIScope *Scope = DTy->getScope();
+
+    APSInt Value;
+    if (const ConstantInt *CI =
+            dyn_cast_or_null<ConstantInt>(DTy->getConstant()))
+      Value = APSInt(CI->getValue(),
+                     DebugHandlerBase::isUnsignedDIType(DTy->getBaseType()));
+    else if (const ConstantFP *CFP =
+                 dyn_cast_or_null<ConstantFP>(DTy->getConstant()))
+      Value = APSInt(CFP->getValueAPF().bitcastToAPInt(), true);
+    else
+      llvm_unreachable("cannot emit a constant without a value");
+
+    emitConstantSymbolRecord(DTy->getBaseType(), Value,
+                             getFullyQualifiedName(Scope, DTy->getName()));
+  }
 }
 
 static bool isFloatDIType(const DIType *Ty) {
   if (isa<DICompositeType>(Ty))
     return false;
 
   if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
     dwarf::Tag T = (dwarf::Tag)Ty->getTag();
if (const GlobalVariable *GV =
     assert(DIE->isConstant() &&
            "Global constant variables must contain a constant expression.");
 
     // Use unsigned for floats.
     bool isUnsigned = isFloatDIType(DIGV->getType())
                           ? true
                           : DebugHandlerBase::isUnsignedDIType(DIGV->getType());
     APSInt Value(APInt(/*BitWidth=*/64, DIE->getElement(1)), isUnsigned);
-
-    MCSymbol *SConstantEnd = beginSymbolRecord(SymbolKind::S_CONSTANT);
-    OS.AddComment("Type");
-    OS.emitInt32(getTypeIndex(DIGV->getType()).getIndex());
-    OS.AddComment("Value");
-
-    // Encoded integers shouldn't need more than 10 bytes.
-    uint8_t data[10];
-    BinaryStreamWriter Writer(data, llvm::support::endianness::little);
-    CodeViewRecordIO IO(Writer);
-    cantFail(IO.mapEncodedInteger(Value));
-    StringRef SRef((char *)data, Writer.getOffset());
-    OS.emitBinaryData(SRef);
-
-    OS.AddComment("Name");
-    emitNullTerminatedSymbolName(OS, QualifiedName);
-    endSymbolRecord(SConstantEnd);
+    emitConstantSymbolRecord(DIGV->getType(), Value, QualifiedName);
   }
 }

llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp

if (auto EC = consume(*Reader, N))
       return EC;
     Value = N.getZExtValue();
   }
   return Error::success();
 }
 
 Error CodeViewRecordIO::mapEncodedInteger(APSInt &Value, const Twine &Comment) {
   if (isStreaming()) {
+    // FIXME: We also need to handle big values here, but it's
+    //        not clear how we can excercise this code path yet.
     if (Value.isSigned())
       emitEncodedSignedInteger(Value.getSExtValue(), Comment);
     else
       emitEncodedUnsignedInteger(Value.getZExtValue(), Comment);
   } else if (isWriting()) {
     if (Value.isSigned())
-      return writeEncodedSignedInteger(Value.getSExtValue());
-    return writeEncodedUnsignedInteger(Value.getZExtValue());
+      return writeEncodedSignedInteger(
+          Value.isSingleWord() ? Value.getSExtValue() : INT64_MIN);
+    return writeEncodedUnsignedInteger(Value.getLimitedValue());
   } else
     return consume(*Reader, Value);
   return Error::success();
 }
 
 Error CodeViewRecordIO::mapStringZ(StringRef &Value, const Twine &Comment) {
   if (isStreaming()) {
     auto NullTerminatedString = StringRef(Value.data(), Value.size() + 1);
     emitComment(Comment);
     Streamer->emitBytes(NullTerminatedString);
     incrStreamedLen(NullTerminatedString.size());
   } else if (isWriting()) {
while (!S.empty()) {
         return EC;
     };
   }
   return Error::success();
 }
 
 void CodeViewRecordIO::emitEncodedSignedInteger(const int64_t &Value,
                                                 const Twine &Comment) {
+  // FIXME: There are no test cases covering this function.
+  // This may be because we always consider enumerators to be unsigned.
+  // See FIXME at CodeViewDebug.cpp : CodeViewDebug::lowerTypeEnum.
   if (Value >= std::numeric_limits<int8_t>::min()) {
     Streamer->emitIntValue(LF_CHAR, 2);
     emitComment(Comment);
     Streamer->emitIntValue(Value, 1);
     incrStreamedLen(3);
   } else if (Value >= std::numeric_limits<int16_t>::min()) {
     Streamer->emitIntValue(LF_SHORT, 2);
     emitComment(Comment);
     Streamer->emitIntValue(Value, 2);
     incrStreamedLen(4);
   } else if (Value >= std::numeric_limits<int32_t>::min()) {
     Streamer->emitIntValue(LF_LONG, 2);
     emitComment(Comment);
     Streamer->emitIntValue(Value, 4);
     incrStreamedLen(6);
   } else {
     Streamer->emitIntValue(LF_QUADWORD, 2);
     emitComment(Comment);
-    Streamer->emitIntValue(Value, 4);
-    incrStreamedLen(6);
+    Streamer->emitIntValue(Value, 4); // FIXME: Why not 8 (size of quadword)?
+    incrStreamedLen(6);               // FIXME: Why not 10 (8 + 2)?
   }
 }
 
 void CodeViewRecordIO::emitEncodedUnsignedInteger(const uint64_t &Value,
                                                   const Twine &Comment) {
   if (Value < LF_NUMERIC) {
     emitComment(Comment);
     Streamer->emitIntValue(Value, 2);
     incrStreamedLen(2);
   } else if (Value <= std::numeric_limits<uint16_t>::max()) {
     Streamer->emitIntValue(LF_USHORT, 2);
     emitComment(Comment);
     Streamer->emitIntValue(Value, 2);
     incrStreamedLen(4);
   } else if (Value <= std::numeric_limits<uint32_t>::max()) {
     Streamer->emitIntValue(LF_ULONG, 2);
     emitComment(Comment);
     Streamer->emitIntValue(Value, 4);
     incrStreamedLen(6);
   } else {
+    // FIXME: There are no test cases covering this block.
     Streamer->emitIntValue(LF_UQUADWORD, 2);
     emitComment(Comment);
     Streamer->emitIntValue(Value, 8);
-    incrStreamedLen(6);
+    incrStreamedLen(6); // FIXME: Why not 10 (8 + 2)?
   }
 }
 
 Error CodeViewRecordIO::writeEncodedSignedInteger(const int64_t &Value) {
   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))

llvm/lib/IR/DIBuilder.cpp

DIMacroFile *DIBuilder::createTempMacroFile(DIMacroFile *Parent,
   AllMacrosPerParent[Parent].insert(MF);
   // Add the new temporary DIMacroFile to the macro per parent map as a parent.
   // This is needed to assure DIMacroFile with no children to have an entry in
   // the map. Otherwise, it will not be resolved in DIBuilder::finalize().
   AllMacrosPerParent.insert({MF, {}});
   return MF;
 }
 
-DIEnumerator *DIBuilder::createEnumerator(StringRef Name, int64_t Val,
+DIEnumerator *DIBuilder::createEnumerator(StringRef Name, uint64_t Val,
                                           bool IsUnsigned) {
   assert(!Name.empty() && "Unable to create enumerator without name");
   return DIEnumerator::get(VMContext, APInt(64, Val, !IsUnsigned), IsUnsigned,
                            Name);
 }
 
 DIEnumerator *DIBuilder::createEnumerator(StringRef Name, APSInt Value) {
   assert(!Name.empty() && "Unable to create enumerator without name");
   return DIEnumerator::get(VMContext, APInt(Value), Value.isUnsigned(), Name);
 }
 

llvm/test/DebugInfo/COFF/integer-128.ll

+; RUN: llc < %s | FileCheck %s --check-prefix=ASM
+
+; // C++ source to regenerate:
+; enum class uns : __uint128_t { unsval = __uint128_t(1) << 64 };
+; uns t1() { return uns::unsval; }
+; enum class sig : __int128 { sigval = -(__int128(1) << 64) };
+; sig t2() { return sig::sigval; }
+; struct test {
+;   static const __uint128_t u128 = __uint128_t(1) << 64;
+;   static const __int128    s128 = -(__int128(1) << 64);
+; };
+; test t3() { return test(); }
+; 
+; $ clang a.cpp -S -emit-llvm -g -gcodeview
+
+; ------------------------------------------------------------------------------
+
+; ASM-LABEL: .long   241                             # Symbol subsection for globals
+;
+; ASM-LABEL: .short 4359                            # Record kind: S_CONSTANT
+; ASM-NEXT:  .long  4110                            # Type
+; ASM-NEXT:  .byte  0x0a, 0x80, 0xff, 0xff          # Value
+; ASM-NEXT:  .byte  0xff, 0xff, 0xff, 0xff
+; ASM-NEXT:  .byte  0xff, 0xff
+; ASM-NEXT:  .asciz "test::u128"                    # Name
+; ASM-NEXT:  .p2align 2
+;
+; ASM-LABEL: .short 4359                            # Record kind: S_CONSTANT
+; ASM-NEXT:  .long  4111                            # Type
+; ASM-NEXT:  .byte  0x09, 0x80, 0x00, 0x00          # Value
+; ASM-NEXT:  .byte  0x00, 0x00, 0x00, 0x00
+; ASM-NEXT:  .byte  0x00, 0x80
+; ASM-NEXT:  .asciz "test::s128"                    # Name
+; ASM-NEXT:  .p2align 2
+;
+; ASM-LABEL: .short 0x1203                          # Record kind: LF_FIELDLIST
+; ASM-NEXT:  .short 0x1502                          # Member kind: Enumerator ( LF_ENUMERATE )
+; ASM-NEXT:  .short 0x3                             # Attrs: Public
+; ASM-NEXT:  .short 0x800a
+; ASM-NEXT:  .quad  0xffffffffffffffff              # EnumValue
+; ASM-NEXT:  .asciz "unsval"                        # Name
+;
+; ASM-LABEL: .short 0x1203                          # Record kind: LF_FIELDLIST
+; ASM-NEXT:  .short 0x1502                          # Member kind: Enumerator ( LF_ENUMERATE )
+; ASM-NEXT:  .short 0x3                             # Attrs: Public
+; ASM-NEXT:  .short 0x800a
+; ASM-NEXT:  .quad  0xffffffffffffffff              # EnumValue
+; ASM-NEXT:  .asciz "sigval"                        # Name
+
+; ------------------------------------------------------------------------------
+
+; ModuleID = 'a.cpp'
+source_filename = "a.cpp"
+target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-windows-gnu"
+
+%struct.test = type { i8 }
+
+; Function Attrs: mustprogress noinline nounwind optnone
+define dso_local <2 x i64> @_Z2t1v() #0 !dbg !23 {
+entry:
+  %retval = alloca i128, align 16
+  store i128 18446744073709551616, i128* %retval, align 16, !dbg !27
+  %0 = bitcast i128* %retval to <2 x i64>*, !dbg !27
+  %1 = load <2 x i64>, <2 x i64>* %0, align 16, !dbg !27
+  ret <2 x i64> %1, !dbg !27
+}
+
+; Function Attrs: mustprogress noinline nounwind optnone
+define dso_local <2 x i64> @_Z2t2v() #0 !dbg !28 {
+entry:
+  %retval = alloca i128, align 16
+  store i128 -18446744073709551616, i128* %retval, align 16, !dbg !31
+  %0 = bitcast i128* %retval to <2 x i64>*, !dbg !31
+  %1 = load <2 x i64>, <2 x i64>* %0, align 16, !dbg !31
+  ret <2 x i64> %1, !dbg !31
+}
+
+; Function Attrs: mustprogress noinline nounwind optnone
+define dso_local i8 @_Z2t3v() #1 !dbg !32 {
+entry:
+  %retval = alloca %struct.test, align 1
+  %coerce.dive = getelementptr inbounds %struct.test, %struct.test* %retval, i32 0, i32 0, !dbg !41
+  %0 = load i8, i8* %coerce.dive, align 1, !dbg !41
+  ret i8 %0, !dbg !41
+}
+
+attributes #0 = { mustprogress noinline nounwind optnone "frame-pointer"="none" "min-legal-vector-width"="128" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+attributes #1 = { mustprogress noinline nounwind optnone "frame-pointer"="none" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!19, !20, !21}
+!llvm.ident = !{!22}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 13.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !14, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "a.cpp", directory: ".", checksumkind: CSK_MD5, checksum: "b37f4034fd610917975e9c5ff097fa6b")
+!2 = !{!3, !10}
+!3 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "uns", file: !4, line: 4, baseType: !5, size: 128, flags: DIFlagEnumClass, elements: !8, identifier: "_ZTS3uns")
+!4 = !DIFile(filename: "a.cpp", directory: ".", checksumkind: CSK_MD5, checksum: "b37f4034fd610917975e9c5ff097fa6b")
+!5 = !DIDerivedType(tag: DW_TAG_typedef, name: "__uint128_t", file: !6, baseType: !7)
+!6 = !DIFile(filename: "a.cpp", directory: ".")
+!7 = !DIBasicType(name: "unsigned __int128", size: 128, encoding: DW_ATE_unsigned)
+!8 = !{!9}
+!9 = !DIEnumerator(name: "unsval", value: 18446744073709551616, isUnsigned: true)
+!10 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "sig", file: !4, line: 7, baseType: !11, size: 128, flags: DIFlagEnumClass, elements: !12, identifier: "_ZTS3sig")
+!11 = !DIBasicType(name: "__int128", size: 128, encoding: DW_ATE_signed)
+!12 = !{!13}
+!13 = !DIEnumerator(name: "sigval", value: -18446744073709551616)
+!14 = !{!15, !17}
+!15 = !DIGlobalVariableExpression(var: !16, expr: !DIExpression())
+!16 = distinct !DIGlobalVariable(name: "unsval", scope: !0, file: !4, line: 4, type: !3, isLocal: true, isDefinition: true)
+!17 = !DIGlobalVariableExpression(var: !18, expr: !DIExpression())
+!18 = distinct !DIGlobalVariable(name: "sigval", scope: !0, file: !4, line: 7, type: !10, isLocal: true, isDefinition: true)
+!19 = !{i32 2, !"CodeView", i32 1}
+!20 = !{i32 2, !"Debug Info Version", i32 3}
+!21 = !{i32 1, !"wchar_size", i32 2}
+!22 = !{!"clang version 13.0.0"}
+!23 = distinct !DISubprogram(name: "t1", linkageName: "_Z2t1v", scope: !4, file: !4, line: 5, type: !24, scopeLine: 5, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !26)
+!24 = !DISubroutineType(types: !25)
+!25 = !{!3}
+!26 = !{}
+!27 = !DILocation(line: 5, column: 12, scope: !23)
+!28 = distinct !DISubprogram(name: "t2", linkageName: "_Z2t2v", scope: !4, file: !4, line: 8, type: !29, scopeLine: 8, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !26)
+!29 = !DISubroutineType(types: !30)
+!30 = !{!10}
+!31 = !DILocation(line: 8, column: 12, scope: !28)
+!32 = distinct !DISubprogram(name: "t3", linkageName: "_Z2t3v", scope: !4, file: !4, line: 14, type: !33, scopeLine: 14, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !26)
+!33 = !DISubroutineType(types: !34)
+!34 = !{!35}
+!35 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "test", file: !4, line: 10, size: 8, flags: DIFlagTypePassByValue, elements: !36, identifier: "_ZTS4test")
+!36 = !{!37, !39}
+!37 = !DIDerivedType(tag: DW_TAG_member, name: "u128", scope: !35, file: !4, line: 11, baseType: !38, flags: DIFlagStaticMember, extraData: i128 18446744073709551616)
+!38 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !5)
+!39 = !DIDerivedType(tag: DW_TAG_member, name: "s128", scope: !35, file: !4, line: 12, baseType: !40, flags: DIFlagStaticMember, extraData: i128 -18446744073709551616)
+!40 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !11)
+!41 = !DILocation(line: 14, column: 13, scope: !32)