llvm/unittests/IR/ValueTest.cpp

   1 //===- llvm/unittest/IR/ValueTest.cpp - Value unit 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/Value.h"
  10 #include "llvm/AsmParser/Parser.h"
  11 #include "llvm/IR/Function.h"
  12 #include "llvm/IR/IntrinsicInst.h"
  13 #include "llvm/IR/LLVMContext.h"
  14 #include "llvm/IR/Module.h"
  15 #include "llvm/IR/ModuleSlotTracker.h"
  16 #include "llvm/Support/CommandLine.h"
  17 #include "llvm/Support/SourceMgr.h"
  18 #include "gtest/gtest.h"
  19 using namespace llvm;
  20
  21 extern cl::opt<bool> UseNewDbgInfoFormat;
  22
  23 namespace {
  24
  25 TEST(ValueTest, UsedInBasicBlock) {
  26   LLVMContext C;
  27
  28   const char *ModuleString = "define void @f(i32 %x, i32 %y) {\n"
  29                              "bb0:\n"
  30                              "  %y1 = add i32 %y, 1\n"
  31                              "  %y2 = add i32 %y, 1\n"
  32                              "  %y3 = add i32 %y, 1\n"
  33                              "  %y4 = add i32 %y, 1\n"
  34                              "  %y5 = add i32 %y, 1\n"
  35                              "  %y6 = add i32 %y, 1\n"
  36                              "  %y7 = add i32 %y, 1\n"
  37                              "  %y8 = add i32 %x, 1\n"
  38                              "  ret void\n"
  39                              "}\n";
  40   SMDiagnostic Err;
  41   std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
  42
  43   Function *F = M->getFunction("f");
  44
  45   EXPECT_FALSE(F->isUsedInBasicBlock(&F->front()));
  46   EXPECT_TRUE(std::next(F->arg_begin())->isUsedInBasicBlock(&F->front()));
  47   EXPECT_TRUE(F->arg_begin()->isUsedInBasicBlock(&F->front()));
  48 }
  49
  50 TEST(GlobalTest, CreateAddressSpace) {
  51   LLVMContext Ctx;
  52   std::unique_ptr<Module> M(new Module("TestModule", Ctx));
  53   Type *Int8Ty = Type::getInt8Ty(Ctx);
  54   Type *Int32Ty = Type::getInt32Ty(Ctx);
  55
  56   GlobalVariable *Dummy0
  57     = new GlobalVariable(*M,
  58                          Int32Ty,
  59                          true,
  60                          GlobalValue::ExternalLinkage,
  61                          Constant::getAllOnesValue(Int32Ty),
  62                          "dummy",
  63                          nullptr,
  64                          GlobalVariable::NotThreadLocal,
  65                          1);
  66
  67   const Align kMaxAlignment(Value::MaximumAlignment);
  68   EXPECT_TRUE(kMaxAlignment.value() == 4294967296ULL);
  69   Dummy0->setAlignment(kMaxAlignment);
  70   EXPECT_TRUE(Dummy0->getAlign());
  71   EXPECT_EQ(*Dummy0->getAlign(), kMaxAlignment);
  72
  73   // Make sure the address space isn't dropped when returning this.
  74   Constant *Dummy1 = M->getOrInsertGlobal("dummy", Int32Ty);
  75   EXPECT_EQ(Dummy0, Dummy1);
  76   EXPECT_EQ(1u, Dummy1->getType()->getPointerAddressSpace());
  77
  78
  79   // This one requires a bitcast, but the address space must also stay the same.
  80   GlobalVariable *DummyCast0
  81     = new GlobalVariable(*M,
  82                          Int32Ty,
  83                          true,
  84                          GlobalValue::ExternalLinkage,
  85                          Constant::getAllOnesValue(Int32Ty),
  86                          "dummy_cast",
  87                          nullptr,
  88                          GlobalVariable::NotThreadLocal,
  89                          1);
  90
  91   // Make sure the address space isn't dropped when returning this.
  92   Constant *DummyCast1 = M->getOrInsertGlobal("dummy_cast", Int8Ty);
  93   EXPECT_EQ(DummyCast0, DummyCast1);
  94   EXPECT_EQ(1u, DummyCast1->getType()->getPointerAddressSpace());
  95 }
  96
  97 #ifdef GTEST_HAS_DEATH_TEST
  98 #ifndef NDEBUG
  99
 100 TEST(GlobalTest, AlignDeath) {
 101   LLVMContext Ctx;
 102   std::unique_ptr<Module> M(new Module("TestModule", Ctx));
 103   Type *Int32Ty = Type::getInt32Ty(Ctx);
 104   GlobalVariable *Var =
 105       new GlobalVariable(*M, Int32Ty, true, GlobalValue::ExternalLinkage,
 106                          Constant::getAllOnesValue(Int32Ty), "var", nullptr,
 107                          GlobalVariable::NotThreadLocal, 1);
 108
 109   EXPECT_DEATH(Var->setAlignment(Align(8589934592ULL)),
 110                "Alignment is greater than MaximumAlignment");
 111 }
 112 #endif
 113 #endif
 114
 115 TEST(ValueTest, printSlots) {
 116   // Check that Value::print() and Value::printAsOperand() work with and
 117   // without a slot tracker.
 118   LLVMContext C;
 119
 120   const char *ModuleString = "@g0 = external global %500\n"
 121                              "@g1 = external global %900\n"
 122                              "\n"
 123                              "%900 = type { i32, i32 }\n"
 124                              "%500 = type { i32 }\n"
 125                              "\n"
 126                              "define void @f(i32 %x, i32 %y) {\n"
 127                              "entry:\n"
 128                              "  %0 = add i32 %y, 1\n"
 129                              "  %1 = add i32 %y, 1\n"
 130                              "  ret void\n"
 131                              "}\n";
 132   SMDiagnostic Err;
 133   std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
 134
 135   Function *F = M->getFunction("f");
 136   ASSERT_TRUE(F);
 137   ASSERT_FALSE(F->empty());
 138   BasicBlock &BB = F->getEntryBlock();
 139   ASSERT_EQ(3u, BB.size());
 140
 141   Instruction *I0 = &*BB.begin();
 142   ASSERT_TRUE(I0);
 143   Instruction *I1 = &*++BB.begin();
 144   ASSERT_TRUE(I1);
 145
 146   GlobalVariable *G0 = M->getGlobalVariable("g0");
 147   ASSERT_TRUE(G0);
 148   GlobalVariable *G1 = M->getGlobalVariable("g1");
 149   ASSERT_TRUE(G1);
 150
 151   ModuleSlotTracker MST(M.get());
 152
 153 #define CHECK_PRINT(INST, STR)                                                 \
 154   do {                                                                         \
 155     {                                                                          \
 156       std::string S;                                                           \
 157       raw_string_ostream OS(S);                                                \
 158       INST->print(OS);                                                         \
 159       EXPECT_EQ(STR, OS.str());                                                \
 160     }                                                                          \
 161     {                                                                          \
 162       std::string S;                                                           \
 163       raw_string_ostream OS(S);                                                \
 164       INST->print(OS, MST);                                                    \
 165       EXPECT_EQ(STR, OS.str());                                                \
 166     }                                                                          \
 167   } while (false)
 168   CHECK_PRINT(I0, "  %0 = add i32 %y, 1");
 169   CHECK_PRINT(I1, "  %1 = add i32 %y, 1");
 170 #undef CHECK_PRINT
 171
 172 #define CHECK_PRINT_AS_OPERAND(INST, TYPE, STR)                                \
 173   do {                                                                         \
 174     {                                                                          \
 175       std::string S;                                                           \
 176       raw_string_ostream OS(S);                                                \
 177       INST->printAsOperand(OS, TYPE);                                          \
 178       EXPECT_EQ(StringRef(STR), StringRef(OS.str()));                          \
 179     }                                                                          \
 180     {                                                                          \
 181       std::string S;                                                           \
 182       raw_string_ostream OS(S);                                                \
 183       INST->printAsOperand(OS, TYPE, MST);                                     \
 184       EXPECT_EQ(StringRef(STR), StringRef(OS.str()));                          \
 185     }                                                                          \
 186   } while (false)
 187   CHECK_PRINT_AS_OPERAND(I0, false, "%0");
 188   CHECK_PRINT_AS_OPERAND(I1, false, "%1");
 189   CHECK_PRINT_AS_OPERAND(I0, true, "i32 %0");
 190   CHECK_PRINT_AS_OPERAND(I1, true, "i32 %1");
 191   CHECK_PRINT_AS_OPERAND(G0, true, "ptr @g0");
 192   CHECK_PRINT_AS_OPERAND(G1, true, "ptr @g1");
 193 #undef CHECK_PRINT_AS_OPERAND
 194 }
 195
 196 TEST(ValueTest, getLocalSlots) {
 197   // Verify that the getLocalSlot method returns the correct slot numbers.
 198   LLVMContext C;
 199   const char *ModuleString = "define void @f(i32 %x, i32 %y) {\n"
 200                              "entry:\n"
 201                              "  %0 = add i32 %y, 1\n"
 202                              "  %1 = add i32 %y, 1\n"
 203                              "  br label %2\n"
 204                              "\n"
 205                              "  ret void\n"
 206                              "}\n";
 207   SMDiagnostic Err;
 208   std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
 209
 210   Function *F = M->getFunction("f");
 211   ASSERT_TRUE(F);
 212   ASSERT_FALSE(F->empty());
 213   BasicBlock &EntryBB = F->getEntryBlock();
 214   ASSERT_EQ(3u, EntryBB.size());
 215   BasicBlock *BB2 = &*++F->begin();
 216   ASSERT_TRUE(BB2);
 217
 218   Instruction *I0 = &*EntryBB.begin();
 219   ASSERT_TRUE(I0);
 220   Instruction *I1 = &*++EntryBB.begin();
 221   ASSERT_TRUE(I1);
 222
 223   ModuleSlotTracker MST(M.get());
 224   MST.incorporateFunction(*F);
 225   EXPECT_EQ(MST.getLocalSlot(I0), 0);
 226   EXPECT_EQ(MST.getLocalSlot(I1), 1);
 227   EXPECT_EQ(MST.getLocalSlot(&EntryBB), -1);
 228   EXPECT_EQ(MST.getLocalSlot(BB2), 2);
 229 }
 230
 231 #if defined(GTEST_HAS_DEATH_TEST) && !defined(NDEBUG)
 232 TEST(ValueTest, getLocalSlotDeath) {
 233   LLVMContext C;
 234   const char *ModuleString = "define void @f(i32 %x, i32 %y) {\n"
 235                              "entry:\n"
 236                              "  %0 = add i32 %y, 1\n"
 237                              "  %1 = add i32 %y, 1\n"
 238                              "  br label %2\n"
 239                              "\n"
 240                              "  ret void\n"
 241                              "}\n";
 242   SMDiagnostic Err;
 243   std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
 244
 245   Function *F = M->getFunction("f");
 246   ASSERT_TRUE(F);
 247   ASSERT_FALSE(F->empty());
 248   BasicBlock *BB2 = &*++F->begin();
 249   ASSERT_TRUE(BB2);
 250
 251   ModuleSlotTracker MST(M.get());
 252   EXPECT_DEATH(MST.getLocalSlot(BB2), "No function incorporated");
 253 }
 254 #endif
 255
 256 TEST(ValueTest, replaceUsesOutsideBlock) {
 257   // Check that Value::replaceUsesOutsideBlock(New, BB) replaces uses outside
 258   // BB, including dbg.* uses of MetadataAsValue(ValueAsMetadata(this)).
 259   bool OldDbgValueMode = UseNewDbgInfoFormat;
 260   UseNewDbgInfoFormat = false;
 261   const auto *IR = R"(
 262     define i32 @f() !dbg !6 {
 263     entry:
 264       %a = add i32 0, 1, !dbg !15
 265       %b = add i32 0, 2, !dbg !15
 266       %c = add i32 %a, 2, !dbg !15
 267       call void @llvm.dbg.value(metadata i32 %a, metadata !9, metadata !DIExpression()), !dbg !15
 268       br label %exit, !dbg !15
 269
 270     exit:
 271       call void @llvm.dbg.value(metadata i32 %a, metadata !11, metadata !DIExpression()), !dbg !16
 272       ret i32 %a, !dbg !16
 273     }
 274
 275     declare void @llvm.dbg.value(metadata, metadata, metadata)
 276
 277     !llvm.dbg.cu = !{!0}
 278     !llvm.module.flags = !{!5}
 279
 280     !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "debugify", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
 281     !1 = !DIFile(filename: "test.ll", directory: "/")
 282     !2 = !{}
 283     !5 = !{i32 2, !"Debug Info Version", i32 3}
 284     !6 = distinct !DISubprogram(name: "f", linkageName: "f", scope: null, file: !1, line: 1, type: !7, isLocal: false, isDefinition: true, scopeLine: 1, isOptimized: true, unit: !0, retainedNodes: !8)
 285     !7 = !DISubroutineType(types: !2)
 286     !8 = !{!9, !11}
 287     !9 = !DILocalVariable(name: "1", scope: !6, file: !1, line: 1, type: !10)
 288     !10 = !DIBasicType(name: "ty32", size: 32, encoding: DW_ATE_signed)
 289     !11 = !DILocalVariable(name: "2", scope: !6, file: !1, line: 2, type: !12)
 290     !12 = !DIBasicType(name: "ty64", size: 64, encoding: DW_ATE_signed)
 291     !15 = !DILocation(line: 1, column: 1, scope: !6)
 292     !16 = !DILocation(line: 5, column: 1, scope: !6)
 293   )";
 294   LLVMContext Ctx;
 295   SMDiagnostic Err;
 296   std::unique_ptr<Module> M = parseAssemblyString(IR, Err, Ctx);
 297   if (!M)
 298     Err.print("ValueTest", errs());
 299
 300   auto GetNext = [](auto *I) { return &*++I->getIterator(); };
 301
 302   Function *F = M->getFunction("f");
 303   // Entry.
 304   BasicBlock *Entry = &F->front();
 305   Instruction *A = &Entry->front();
 306   Instruction *B = GetNext(A);
 307   Instruction *C = GetNext(B);
 308   auto *EntryDbg = cast<DbgValueInst>(GetNext(C));
 309   // Exit.
 310   BasicBlock *Exit = GetNext(Entry);
 311   auto *ExitDbg = cast<DbgValueInst>(&Exit->front());
 312   Instruction *Ret = GetNext(ExitDbg);
 313
 314   A->replaceUsesOutsideBlock(B, Entry);
 315   // These users are in Entry so shouldn't be changed.
 316   ASSERT_TRUE(C->getOperand(0) == cast<Value>(A));
 317   ASSERT_TRUE(EntryDbg->getValue(0) == cast<Value>(A));
 318   // These users are outside Entry so should be changed.
 319   ASSERT_TRUE(ExitDbg->getValue(0) == cast<Value>(B));
 320   ASSERT_TRUE(Ret->getOperand(0) == cast<Value>(B));
 321   UseNewDbgInfoFormat = OldDbgValueMode;
 322 }
 323
 324 TEST(ValueTest, replaceUsesOutsideBlockDbgVariableRecord) {
 325   // Check that Value::replaceUsesOutsideBlock(New, BB) replaces uses outside
 326   // BB, including DbgVariableRecords.
 327   const auto *IR = R"(
 328     define i32 @f() !dbg !6 {
 329     entry:
 330       %a = add i32 0, 1, !dbg !15
 331       %b = add i32 0, 2, !dbg !15
 332       %c = add i32 %a, 2, !dbg !15
 333       call void @llvm.dbg.value(metadata i32 %a, metadata !9, metadata !DIExpression()), !dbg !15
 334       br label %exit, !dbg !15
 335
 336     exit:
 337       call void @llvm.dbg.value(metadata i32 %a, metadata !11, metadata !DIExpression()), !dbg !16
 338       ret i32 %a, !dbg !16
 339     }
 340
 341     declare void @llvm.dbg.value(metadata, metadata, metadata)
 342
 343     !llvm.dbg.cu = !{!0}
 344     !llvm.module.flags = !{!5}
 345
 346     !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "debugify", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
 347     !1 = !DIFile(filename: "test.ll", directory: "/")
 348     !2 = !{}
 349     !5 = !{i32 2, !"Debug Info Version", i32 3}
 350     !6 = distinct !DISubprogram(name: "f", linkageName: "f", scope: null, file: !1, line: 1, type: !7, isLocal: false, isDefinition: true, scopeLine: 1, isOptimized: true, unit: !0, retainedNodes: !8)
 351     !7 = !DISubroutineType(types: !2)
 352     !8 = !{!9, !11}
 353     !9 = !DILocalVariable(name: "1", scope: !6, file: !1, line: 1, type: !10)
 354     !10 = !DIBasicType(name: "ty32", size: 32, encoding: DW_ATE_signed)
 355     !11 = !DILocalVariable(name: "2", scope: !6, file: !1, line: 2, type: !12)
 356     !12 = !DIBasicType(name: "ty64", size: 64, encoding: DW_ATE_signed)
 357     !15 = !DILocation(line: 1, column: 1, scope: !6)
 358     !16 = !DILocation(line: 5, column: 1, scope: !6)
 359   )";
 360   LLVMContext Ctx;
 361   SMDiagnostic Err;
 362   std::unique_ptr<Module> M = parseAssemblyString(IR, Err, Ctx);
 363   if (!M)
 364     Err.print("ValueTest", errs());
 365
 366   auto GetNext = [](auto *I) { return &*++I->getIterator(); };
 367
 368   Function *F = M->getFunction("f");
 369   // Entry.
 370   BasicBlock *Entry = &F->front();
 371   Instruction *A = &Entry->front();
 372   Instruction *B = GetNext(A);
 373   Instruction *C = GetNext(B);
 374   Instruction *Branch = GetNext(C);
 375   // Exit.
 376   BasicBlock *Exit = GetNext(Entry);
 377   Instruction *Ret = &Exit->front();
 378
 379   EXPECT_TRUE(Branch->hasDbgRecords());
 380   EXPECT_TRUE(Ret->hasDbgRecords());
 381
 382   DbgVariableRecord *DVR1 =
 383       cast<DbgVariableRecord>(&*Branch->getDbgRecordRange().begin());
 384   DbgVariableRecord *DVR2 =
 385       cast<DbgVariableRecord>(&*Ret->getDbgRecordRange().begin());
 386
 387   A->replaceUsesOutsideBlock(B, Entry);
 388   // These users are in Entry so shouldn't be changed.
 389   EXPECT_TRUE(DVR1->getVariableLocationOp(0) == cast<Value>(A));
 390   // These users are outside Entry so should be changed.
 391   EXPECT_TRUE(DVR2->getVariableLocationOp(0) == cast<Value>(B));
 392 }
 393
 394 } // end anonymous namespace