llvm/unittests/IR/DebugInfoTest.cpp

   1 //===- llvm/unittest/IR/DebugInfo.cpp - DebugInfo tests -------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/IR/DebugInfo.h"
  10 #include "llvm/ADT/APSInt.h"
  11 #include "llvm/AsmParser/Parser.h"
  12 #include "llvm/IR/DIBuilder.h"
  13 #include "llvm/IR/DebugInfoMetadata.h"
  14 #include "llvm/IR/IRBuilder.h"
  15 #include "llvm/IR/IntrinsicInst.h"
  16 #include "llvm/IR/LLVMContext.h"
  17 #include "llvm/IR/Metadata.h"
  18 #include "llvm/IR/Module.h"
  19 #include "llvm/IR/Verifier.h"
  20 #include "llvm/Support/SourceMgr.h"
  21 #include "llvm/Transforms/Utils/Local.h"
  22 #include "gtest/gtest.h"
  23
  24 using namespace llvm;
  25
  26 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
  27   SMDiagnostic Err;
  28   std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
  29   if (!Mod)
  30     Err.print("DebugInfoTest", errs());
  31   return Mod;
  32 }
  33
  34 namespace {
  35
  36 TEST(DINodeTest, getFlag) {
  37   // Some valid flags.
  38   EXPECT_EQ(DINode::FlagPublic, DINode::getFlag("DIFlagPublic"));
  39   EXPECT_EQ(DINode::FlagProtected, DINode::getFlag("DIFlagProtected"));
  40   EXPECT_EQ(DINode::FlagPrivate, DINode::getFlag("DIFlagPrivate"));
  41   EXPECT_EQ(DINode::FlagVector, DINode::getFlag("DIFlagVector"));
  42   EXPECT_EQ(DINode::FlagRValueReference,
  43             DINode::getFlag("DIFlagRValueReference"));
  44
  45   // FlagAccessibility shouldn't work.
  46   EXPECT_EQ(0u, DINode::getFlag("DIFlagAccessibility"));
  47
  48   // Some other invalid strings.
  49   EXPECT_EQ(0u, DINode::getFlag("FlagVector"));
  50   EXPECT_EQ(0u, DINode::getFlag("Vector"));
  51   EXPECT_EQ(0u, DINode::getFlag("other things"));
  52   EXPECT_EQ(0u, DINode::getFlag("DIFlagOther"));
  53 }
  54
  55 TEST(DINodeTest, getFlagString) {
  56   // Some valid flags.
  57   EXPECT_EQ(StringRef("DIFlagPublic"),
  58             DINode::getFlagString(DINode::FlagPublic));
  59   EXPECT_EQ(StringRef("DIFlagProtected"),
  60             DINode::getFlagString(DINode::FlagProtected));
  61   EXPECT_EQ(StringRef("DIFlagPrivate"),
  62             DINode::getFlagString(DINode::FlagPrivate));
  63   EXPECT_EQ(StringRef("DIFlagVector"),
  64             DINode::getFlagString(DINode::FlagVector));
  65   EXPECT_EQ(StringRef("DIFlagRValueReference"),
  66             DINode::getFlagString(DINode::FlagRValueReference));
  67
  68   // FlagAccessibility actually equals FlagPublic.
  69   EXPECT_EQ(StringRef("DIFlagPublic"),
  70             DINode::getFlagString(DINode::FlagAccessibility));
  71
  72   // Some other invalid flags.
  73   EXPECT_EQ(StringRef(),
  74             DINode::getFlagString(DINode::FlagPublic | DINode::FlagVector));
  75   EXPECT_EQ(StringRef(), DINode::getFlagString(DINode::FlagFwdDecl |
  76                                                DINode::FlagArtificial));
  77   EXPECT_EQ(StringRef(),
  78             DINode::getFlagString(static_cast<DINode::DIFlags>(0xffff)));
  79 }
  80
  81 TEST(DINodeTest, splitFlags) {
  82 // Some valid flags.
  83 #define CHECK_SPLIT(FLAGS, VECTOR, REMAINDER)                                  \
  84   {                                                                            \
  85     SmallVector<DINode::DIFlags, 8> V;                                         \
  86     EXPECT_EQ(REMAINDER, DINode::splitFlags(FLAGS, V));                        \
  87     EXPECT_TRUE(makeArrayRef(V).equals(VECTOR));                               \
  88   }
  89   CHECK_SPLIT(DINode::FlagPublic, {DINode::FlagPublic}, DINode::FlagZero);
  90   CHECK_SPLIT(DINode::FlagProtected, {DINode::FlagProtected}, DINode::FlagZero);
  91   CHECK_SPLIT(DINode::FlagPrivate, {DINode::FlagPrivate}, DINode::FlagZero);
  92   CHECK_SPLIT(DINode::FlagVector, {DINode::FlagVector}, DINode::FlagZero);
  93   CHECK_SPLIT(DINode::FlagRValueReference, {DINode::FlagRValueReference},
  94               DINode::FlagZero);
  95   DINode::DIFlags Flags[] = {DINode::FlagFwdDecl, DINode::FlagVector};
  96   CHECK_SPLIT(DINode::FlagFwdDecl | DINode::FlagVector, Flags,
  97               DINode::FlagZero);
  98   CHECK_SPLIT(DINode::FlagZero, {}, DINode::FlagZero);
  99 #undef CHECK_SPLIT
 100 }
 101
 102 TEST(StripTest, LoopMetadata) {
 103   LLVMContext C;
 104   std::unique_ptr<Module> M = parseIR(C, R"(
 105     define void @f() !dbg !5 {
 106       ret void, !dbg !10, !llvm.loop !11
 107     }
 108
 109     !llvm.dbg.cu = !{!0}
 110     !llvm.debugify = !{!3, !3}
 111     !llvm.module.flags = !{!4}
 112
 113     !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "debugify", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
 114     !1 = !DIFile(filename: "loop.ll", directory: "/")
 115     !2 = !{}
 116     !3 = !{i32 1}
 117     !4 = !{i32 2, !"Debug Info Version", i32 3}
 118     !5 = distinct !DISubprogram(name: "f", linkageName: "f", scope: null, file: !1, line: 1, type: !6, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !7)
 119     !6 = !DISubroutineType(types: !2)
 120     !7 = !{!8}
 121     !8 = !DILocalVariable(name: "1", scope: !5, file: !1, line: 1, type: !9)
 122     !9 = !DIBasicType(name: "ty32", size: 32, encoding: DW_ATE_unsigned)
 123     !10 = !DILocation(line: 1, column: 1, scope: !5)
 124     !11 = distinct !{!11, !10, !10}
 125 )");
 126
 127   // Look up the debug info emission kind for the CU via the loop metadata
 128   // attached to the terminator. If, when stripping non-line table debug info,
 129   // we update the terminator's metadata correctly, we should be able to
 130   // observe the change in emission kind for the CU.
 131   auto getEmissionKind = [&]() {
 132     Instruction &I = *M->getFunction("f")->getEntryBlock().getFirstNonPHI();
 133     MDNode *LoopMD = I.getMetadata(LLVMContext::MD_loop);
 134     return cast<DILocation>(LoopMD->getOperand(1))
 135         ->getScope()
 136         ->getSubprogram()
 137         ->getUnit()
 138         ->getEmissionKind();
 139   };
 140
 141   EXPECT_EQ(getEmissionKind(), DICompileUnit::FullDebug);
 142
 143   bool Changed = stripNonLineTableDebugInfo(*M);
 144   EXPECT_TRUE(Changed);
 145
 146   EXPECT_EQ(getEmissionKind(), DICompileUnit::LineTablesOnly);
 147
 148   bool BrokenDebugInfo = false;
 149   bool HardError = verifyModule(*M, &errs(), &BrokenDebugInfo);
 150   EXPECT_FALSE(HardError);
 151   EXPECT_FALSE(BrokenDebugInfo);
 152 }
 153
 154 TEST(MetadataTest, DeleteInstUsedByDbgValue) {
 155   LLVMContext C;
 156   std::unique_ptr<Module> M = parseIR(C, R"(
 157     define i16 @f(i16 %a) !dbg !6 {
 158       %b = add i16 %a, 1, !dbg !11
 159       call void @llvm.dbg.value(metadata i16 %b, metadata !9, metadata !DIExpression()), !dbg !11
 160       ret i16 0, !dbg !11
 161     }
 162     declare void @llvm.dbg.value(metadata, metadata, metadata) #0
 163     attributes #0 = { nounwind readnone speculatable willreturn }
 164
 165     !llvm.dbg.cu = !{!0}
 166     !llvm.module.flags = !{!5}
 167
 168     !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "debugify", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
 169     !1 = !DIFile(filename: "t.ll", directory: "/")
 170     !2 = !{}
 171     !5 = !{i32 2, !"Debug Info Version", i32 3}
 172     !6 = distinct !DISubprogram(name: "foo", linkageName: "foo", scope: null, file: !1, line: 1, type: !7, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !8)
 173     !7 = !DISubroutineType(types: !2)
 174     !8 = !{!9}
 175     !9 = !DILocalVariable(name: "1", scope: !6, file: !1, line: 1, type: !10)
 176     !10 = !DIBasicType(name: "ty16", size: 16, encoding: DW_ATE_unsigned)
 177     !11 = !DILocation(line: 1, column: 1, scope: !6)
 178 )");
 179
 180   // Find %b = add ...
 181   Instruction &I = *M->getFunction("f")->getEntryBlock().getFirstNonPHI();
 182
 183   // Find the dbg.value using %b.
 184   SmallVector<DbgValueInst *, 1> DVIs;
 185   findDbgValues(DVIs, &I);
 186
 187   // Delete %b. The dbg.value should now point to undef.
 188   I.eraseFromParent();
 189   EXPECT_EQ(DVIs[0]->getNumVariableLocationOps(), 1u);
 190   EXPECT_TRUE(isa<UndefValue>(DVIs[0]->getValue(0)));
 191 }
 192
 193 TEST(DIBuilder, CreateFortranArrayTypeWithAttributes) {
 194   LLVMContext Ctx;
 195   std::unique_ptr<Module> M(new Module("MyModule", Ctx));
 196   DIBuilder DIB(*M);
 197
 198   DISubrange *Subrange = DIB.getOrCreateSubrange(1,1);
 199   SmallVector<Metadata*, 4> Subranges;
 200   Subranges.push_back(Subrange);
 201   DINodeArray Subscripts = DIB.getOrCreateArray(Subranges);
 202
 203   auto getDIExpression = [&DIB](int offset) {
 204     SmallVector<uint64_t, 4> ops;
 205     ops.push_back(llvm::dwarf::DW_OP_push_object_address);
 206     DIExpression::appendOffset(ops, offset);
 207     ops.push_back(llvm::dwarf::DW_OP_deref);
 208
 209     return DIB.createExpression(ops);
 210   };
 211
 212   DIFile *F = DIB.createFile("main.c", "/");
 213   DICompileUnit *CU = DIB.createCompileUnit(
 214       dwarf::DW_LANG_C, DIB.createFile("main.c", "/"), "llvm-c", true, "", 0);
 215
 216   DIVariable *DataLocation =
 217       DIB.createTempGlobalVariableFwdDecl(CU, "dl", "_dl", F, 1, nullptr, true);
 218   DIExpression *Associated = getDIExpression(1);
 219   DIExpression *Allocated = getDIExpression(2);
 220   DIExpression *Rank = DIB.createConstantValueExpression(3);
 221
 222   DICompositeType *ArrayType = DIB.createArrayType(0, 0, nullptr, Subscripts,
 223                                                    DataLocation, Associated,
 224                                                    Allocated, Rank);
 225
 226   EXPECT_TRUE(isa_and_nonnull<DICompositeType>(ArrayType));
 227   EXPECT_EQ(ArrayType->getRawDataLocation(), DataLocation);
 228   EXPECT_EQ(ArrayType->getRawAssociated(), Associated);
 229   EXPECT_EQ(ArrayType->getRawAllocated(), Allocated);
 230   EXPECT_EQ(ArrayType->getRawRank(), Rank);
 231
 232   // Avoid memory leak.
 233   DIVariable::deleteTemporary(DataLocation);
 234 }
 235
 236 TEST(DIBuilder, CreateSetType) {
 237   LLVMContext Ctx;
 238   std::unique_ptr<Module> M(new Module("MyModule", Ctx));
 239   DIBuilder DIB(*M);
 240   DIScope *Scope = DISubprogram::getDistinct(
 241       Ctx, nullptr, "", "", nullptr, 0, nullptr, 0, nullptr, 0, 0,
 242       DINode::FlagZero, DISubprogram::SPFlagZero, nullptr);
 243   DIType *Type = DIB.createBasicType("Int", 64, dwarf::DW_ATE_signed);
 244   DIFile *F = DIB.createFile("main.c", "/");
 245
 246   DIDerivedType *SetType = DIB.createSetType(Scope, "set1", F, 1, 64, 64, Type);
 247   EXPECT_TRUE(isa_and_nonnull<DIDerivedType>(SetType));
 248 }
 249
 250 TEST(DIBuilder, CreateStringType) {
 251   LLVMContext Ctx;
 252   std::unique_ptr<Module> M(new Module("MyModule", Ctx));
 253   DIBuilder DIB(*M);
 254   DIScope *Scope = DISubprogram::getDistinct(
 255       Ctx, nullptr, "", "", nullptr, 0, nullptr, 0, nullptr, 0, 0,
 256       DINode::FlagZero, DISubprogram::SPFlagZero, nullptr);
 257   DIFile *F = DIB.createFile("main.c", "/");
 258   StringRef StrName = "string";
 259   DIVariable *StringLen = DIB.createAutoVariable(Scope, StrName, F, 0, nullptr,
 260                                                  false, DINode::FlagZero, 0);
 261   auto getDIExpression = [&DIB](int offset) {
 262     SmallVector<uint64_t, 4> ops;
 263     ops.push_back(llvm::dwarf::DW_OP_push_object_address);
 264     DIExpression::appendOffset(ops, offset);
 265     ops.push_back(llvm::dwarf::DW_OP_deref);
 266
 267     return DIB.createExpression(ops);
 268   };
 269   DIExpression *StringLocationExp = getDIExpression(1);
 270   DIStringType *StringType =
 271       DIB.createStringType(StrName, StringLen, StringLocationExp);
 272
 273   EXPECT_TRUE(isa_and_nonnull<DIStringType>(StringType));
 274   EXPECT_EQ(StringType->getName(), StrName);
 275   EXPECT_EQ(StringType->getStringLength(), StringLen);
 276   EXPECT_EQ(StringType->getStringLocationExp(), StringLocationExp);
 277
 278   StringRef StrNameExp = "stringexp";
 279   DIExpression *StringLengthExp = getDIExpression(2);
 280   DIStringType *StringTypeExp =
 281       DIB.createStringType(StrNameExp, StringLengthExp, StringLocationExp);
 282
 283   EXPECT_TRUE(isa_and_nonnull<DIStringType>(StringTypeExp));
 284   EXPECT_EQ(StringTypeExp->getName(), StrNameExp);
 285   EXPECT_EQ(StringTypeExp->getStringLocationExp(), StringLocationExp);
 286   EXPECT_EQ(StringTypeExp->getStringLengthExp(), StringLengthExp);
 287 }
 288
 289 TEST(DIBuilder, DIEnumerator) {
 290   LLVMContext Ctx;
 291   std::unique_ptr<Module> M(new Module("MyModule", Ctx));
 292   DIBuilder DIB(*M);
 293   APSInt I1(APInt(32, 1));
 294   APSInt I2(APInt(33, 1));
 295
 296   auto *E = DIEnumerator::get(Ctx, I1, I1.isSigned(), "name");
 297   EXPECT_TRUE(E);
 298
 299   auto *E1 = DIEnumerator::getIfExists(Ctx, I1, I1.isSigned(), "name");
 300   EXPECT_TRUE(E1);
 301
 302   auto *E2 = DIEnumerator::getIfExists(Ctx, I2, I1.isSigned(), "name");
 303   EXPECT_FALSE(E2);
 304 }
 305
 306 TEST(DIBuilder, createDbgAddr) {
 307   LLVMContext C;
 308   std::unique_ptr<Module> M = parseIR(C, R"(
 309     define void @f() !dbg !6 {
 310       %a = alloca i16, align 8
 311       ;; It is important that we put the debug marker on the return.
 312       ;; We take advantage of that to conjure up a debug loc without
 313       ;; having to synthesize one programatically.
 314       ret void, !dbg !11
 315     }
 316     declare void @llvm.dbg.value(metadata, metadata, metadata) #0
 317     attributes #0 = { nounwind readnone speculatable willreturn }
 318
 319     !llvm.dbg.cu = !{!0}
 320     !llvm.module.flags = !{!5}
 321
 322     !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "debugify", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
 323     !1 = !DIFile(filename: "t.ll", directory: "/")
 324     !2 = !{}
 325     !5 = !{i32 2, !"Debug Info Version", i32 3}
 326     !6 = distinct !DISubprogram(name: "foo", linkageName: "foo", scope: null, file: !1, line: 1, type: !7, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !8)
 327     !7 = !DISubroutineType(types: !2)
 328     !8 = !{!9}
 329     !9 = !DILocalVariable(name: "1", scope: !6, file: !1, line: 1, type: !10)
 330     !10 = !DIBasicType(name: "ty16", size: 16, encoding: DW_ATE_unsigned)
 331     !11 = !DILocation(line: 1, column: 1, scope: !6)
 332 )");
 333   auto *F = M->getFunction("f");
 334   auto *EntryBlock = &F->getEntryBlock();
 335
 336   auto *CU =
 337       cast<DICompileUnit>(M->getNamedMetadata("llvm.dbg.cu")->getOperand(0));
 338   auto *Alloca = &*EntryBlock->begin();
 339   auto *Ret = EntryBlock->getTerminator();
 340
 341   auto *SP = cast<DISubprogram>(F->getMetadata(LLVMContext::MD_dbg));
 342   auto *File = SP->getFile();
 343   std::string Name = "myName";
 344   const auto *Loc = Ret->getDebugLoc().get();
 345
 346   IRBuilder<> Builder(EntryBlock);
 347   DIBuilder DIB(*M, true, CU);
 348   DIType *DT = DIB.createBasicType("ty16", 16, dwarf::DW_ATE_unsigned);
 349
 350   DILocalVariable *LocalVar =
 351       DIB.createAutoVariable(SP, Name, File, 5 /*line*/, DT,
 352                              /*AlwaysPreserve=*/true);
 353
 354   auto *Inst = DIB.insertDbgAddrIntrinsic(Alloca, LocalVar,
 355                                           DIB.createExpression(), Loc, Ret);
 356
 357   DIB.finalize();
 358
 359   EXPECT_EQ(Inst->getDebugLoc().get(), Loc);
 360
 361   auto *MD0 = cast<MetadataAsValue>(Inst->getOperand(0))->getMetadata();
 362   auto *MD0Local = cast<LocalAsMetadata>(MD0);
 363   EXPECT_EQ(MD0Local->getValue(), Alloca);
 364   auto *MD1 = cast<MetadataAsValue>(Inst->getOperand(1))->getMetadata();
 365   EXPECT_EQ(MD1->getMetadataID(), Metadata::MetadataKind::DILocalVariableKind);
 366   auto *MD2 = cast<MetadataAsValue>(Inst->getOperand(2))->getMetadata();
 367   auto *MDExp = cast<DIExpression>(MD2);
 368   EXPECT_EQ(MDExp->getNumElements(), 0u);
 369 }
 370
 371 } // end namespace