[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

3166

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

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

200

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

204

This can be Value.getLimitedValue().

283

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

3166

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

22 ↗

(On Diff #361547)

(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

3166

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!

clang/lib/CodeGen/CGDebugInfo.cpp

llvm::DIType *CGDebugInfo::CreateTypeDefinition(const EnumType *Ty) {
   SmallString<256> Identifier = getTypeIdentifier(Ty, CGM, TheCU);
 
   // Create elements for each enumerator.
   SmallVector<llvm::Metadata *, 16> Enumerators;
   ED = ED->getDefinition();
   bool IsSigned = ED->getIntegerType()->isSignedIntegerType();
   for (const auto *Enum : ED->enumerators()) {
     const auto &InitVal = Enum->getInitVal();
-    auto Value = IsSigned ? InitVal.getSExtValue() : InitVal.getZExtValue();
+    uint64_t Value =
+        IsSigned
+            ? (InitVal.getNumWords() <= 1U ? InitVal.getSExtValue() : INT64_MIN)
+            : (InitVal.getNumWords() <= 1U ? InitVal.getZExtValue()
+                                           : UINT64_MAX);
     Enumerators.push_back(
         DBuilder.createEnumerator(Enum->getName(), Value, !IsSigned));
   }
 
   // Return a CompositeType for the enum itself.
   llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators);
 
   llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation());

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

+// RUN: %clang_cc1 -triple x86_64-windows-gnu -debug-info-kind=limited -gcodeview -S -emit-llvm %s -o - | FileCheck %s --check-prefix=LL
+// RUN: %clang_cc1 -triple x86_64-windows-gnu -debug-info-kind=limited -gcodeview -S %s -o - | FileCheck %s --check-prefix=ASM
+
+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(); }
+
+// LL-LABEL: !DICompositeType(tag: DW_TAG_enumeration_type, name: "uns", {{.*}})
+// LL: !DIEnumerator(name: "unsval", value: 18446744073709551615, isUnsigned: true)
+
+// LL-LABEL: !DICompositeType(tag: DW_TAG_enumeration_type, name: "sig", {{.*}})
+// LL: !DIEnumerator(name: "sigval", value: -9223372036854775808)
+
+// LL-LABEL: distinct !DICompositeType(tag: DW_TAG_structure_type, name: "test", {{.*}})
+// LL: !DIDerivedType(tag: DW_TAG_member, name: "u128", {{.*}}, flags: DIFlagStaticMember, extraData: i128 18446744073709551616)
+// LL: !DIDerivedType(tag: DW_TAG_member, name: "s128", {{.*}}, flags: DIFlagStaticMember, extraData: i128 -18446744073709551616)
+
+// 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 0x8000000000000000              # EnumValue
+// ASM-NEXT:  .asciz  "sigval"                        # Name

llvm/include/llvm/IR/DIBuilder.h

public:
     /// using the \p Parent relationship.
     /// \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, int64_t Val, bool IsUnsigned = false);
+    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();
 
     /// Create debugging information entry for a basic

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

 // 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());
+
+  // TODO: Need to support bigger ints like __int128.
 
-    // 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());
+    if (Value.isSigned()) {
+      int64_t Val =
+          Value.getNumWords() <= 1U ? Value.getSExtValue() : INT64_MIN;
+      return writeEncodedSignedInteger(Val);
+    }
+    uint64_t Val =
+        Value.getNumWords() <= 1U ? Value.getZExtValue() : UINT64_MAX;
+    return writeEncodedUnsignedInteger(Val);
   } 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);
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.
   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);
 }
 
 DIBasicType *DIBuilder::createUnspecifiedType(StringRef Name) {
   assert(!Name.empty() && "Unable to create type without name");
   return DIBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type, Name);
 }