1 //===----------- llvm/unittest/CodeGen/LexicalScopesTest.cpp --------------===// 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/CodeGen/LexicalScopes.h" 10 #include "llvm/CodeGen/CodeGenTargetMachineImpl.h" 11 #include "llvm/CodeGen/MachineBasicBlock.h" 12 #include "llvm/CodeGen/MachineFunction.h" 13 #include "llvm/CodeGen/MachineInstr.h" 14 #include "llvm/CodeGen/MachineMemOperand.h" 15 #include "llvm/CodeGen/MachineModuleInfo.h" 16 #include "llvm/CodeGen/TargetFrameLowering.h" 17 #include "llvm/CodeGen/TargetInstrInfo.h" 18 #include "llvm/CodeGen/TargetLowering.h" 19 #include "llvm/CodeGen/TargetSubtargetInfo.h" 20 #include "llvm/IR/DIBuilder.h" 21 #include "llvm/IR/DebugInfoMetadata.h" 22 #include "llvm/IR/IRBuilder.h" 23 #include "llvm/IR/Module.h" 24 #include "llvm/IR/ModuleSlotTracker.h" 25 #include "llvm/MC/MCAsmInfo.h" 26 #include "llvm/MC/MCSymbol.h" 27 #include "llvm/MC/TargetRegistry.h" 28 #include "llvm/Support/TargetSelect.h" 29 #include "llvm/Target/TargetOptions.h" 30 31 #include "gtest/gtest.h" 32 33 using namespace llvm; 34 35 namespace { 36 // Include helper functions to ease the manipulation of MachineFunctions 37 #include "MFCommon.inc" 38 39 class LexicalScopesTest : public testing::Test { 40 public: 41 // Boilerplate, 42 LLVMContext Ctx; 43 Module Mod; 44 std::unique_ptr<MachineFunction> MF; 45 DICompileUnit *OurCU; 46 DIFile *OurFile; 47 DISubprogram *OurFunc; 48 DILexicalBlock *OurBlock, *AnotherBlock; 49 DISubprogram *ToInlineFunc; 50 DILexicalBlock *ToInlineBlock; 51 // DebugLocs that we'll used to create test environments. 52 DebugLoc OutermostLoc, InBlockLoc, NotNestedBlockLoc, InlinedLoc; 53 54 // Test environment blocks -- these form a diamond control flow pattern, 55 // MBB1 being the entry block, blocks two and three being the branches, and 56 // block four joining the branches and being an exit block. 57 MachineBasicBlock *MBB1, *MBB2, *MBB3, *MBB4; 58 59 // Some meaningless instructions -- the first is fully meaningless, 60 // while the second is supposed to impersonate DBG_VALUEs through its 61 // opcode. 62 MCInstrDesc BeanInst{}; 63 MCInstrDesc DbgValueInst{}; 64 65 LexicalScopesTest() : Ctx(), Mod("beehives", Ctx) { 66 memset(&BeanInst, 0, sizeof(BeanInst)); 67 BeanInst.Opcode = 1; 68 BeanInst.Size = 1; 69 70 memset(&DbgValueInst, 0, sizeof(DbgValueInst)); 71 DbgValueInst.Opcode = TargetOpcode::DBG_VALUE; 72 DbgValueInst.Size = 1; 73 DbgValueInst.Flags = 1U << MCID::Meta; 74 75 // Boilerplate that creates a MachineFunction and associated blocks. 76 MF = createMachineFunction(Ctx, Mod); 77 llvm::Function &F = const_cast<llvm::Function &>(MF->getFunction()); 78 auto BB1 = BasicBlock::Create(Ctx, "a", &F); 79 auto BB2 = BasicBlock::Create(Ctx, "b", &F); 80 auto BB3 = BasicBlock::Create(Ctx, "c", &F); 81 auto BB4 = BasicBlock::Create(Ctx, "d", &F); 82 IRBuilder<> IRB1(BB1), IRB2(BB2), IRB3(BB3), IRB4(BB4); 83 IRB1.CreateBr(BB2); 84 IRB2.CreateBr(BB3); 85 IRB3.CreateBr(BB4); 86 IRB4.CreateRetVoid(); 87 MBB1 = MF->CreateMachineBasicBlock(BB1); 88 MF->insert(MF->end(), MBB1); 89 MBB2 = MF->CreateMachineBasicBlock(BB2); 90 MF->insert(MF->end(), MBB2); 91 MBB3 = MF->CreateMachineBasicBlock(BB3); 92 MF->insert(MF->end(), MBB3); 93 MBB4 = MF->CreateMachineBasicBlock(BB4); 94 MF->insert(MF->end(), MBB4); 95 MBB1->addSuccessor(MBB2); 96 MBB1->addSuccessor(MBB3); 97 MBB2->addSuccessor(MBB4); 98 MBB3->addSuccessor(MBB4); 99 100 // Create metadata: CU, subprogram, some blocks and an inline function 101 // scope. 102 DIBuilder DIB(Mod); 103 OurFile = DIB.createFile("xyzzy.c", "/cave"); 104 OurCU = 105 DIB.createCompileUnit(dwarf::DW_LANG_C99, OurFile, "nou", false, "", 0); 106 auto OurSubT = DIB.createSubroutineType(DIB.getOrCreateTypeArray({})); 107 OurFunc = 108 DIB.createFunction(OurCU, "bees", "", OurFile, 1, OurSubT, 1, 109 DINode::FlagZero, DISubprogram::SPFlagDefinition); 110 F.setSubprogram(OurFunc); 111 OurBlock = DIB.createLexicalBlock(OurFunc, OurFile, 2, 3); 112 AnotherBlock = DIB.createLexicalBlock(OurFunc, OurFile, 2, 6); 113 ToInlineFunc = 114 DIB.createFunction(OurFile, "shoes", "", OurFile, 10, OurSubT, 10, 115 DINode::FlagZero, DISubprogram::SPFlagDefinition); 116 117 // Make some nested scopes. 118 OutermostLoc = DILocation::get(Ctx, 3, 1, OurFunc); 119 InBlockLoc = DILocation::get(Ctx, 4, 1, OurBlock); 120 InlinedLoc = DILocation::get(Ctx, 10, 1, ToInlineFunc, InBlockLoc.get()); 121 122 // Make a scope that isn't nested within the others. 123 NotNestedBlockLoc = DILocation::get(Ctx, 4, 1, AnotherBlock); 124 125 DIB.finalize(); 126 } 127 }; 128 129 // Fill blocks with dummy instructions, test some base lexical scope 130 // functionaliy. 131 TEST_F(LexicalScopesTest, FlatLayout) { 132 BuildMI(*MBB1, MBB1->end(), OutermostLoc, BeanInst); 133 BuildMI(*MBB2, MBB2->end(), OutermostLoc, BeanInst); 134 BuildMI(*MBB3, MBB3->end(), OutermostLoc, BeanInst); 135 BuildMI(*MBB4, MBB4->end(), OutermostLoc, BeanInst); 136 137 LexicalScopes LS; 138 EXPECT_TRUE(LS.empty()); 139 LS.reset(); 140 EXPECT_EQ(LS.getCurrentFunctionScope(), nullptr); 141 142 LS.initialize(*MF); 143 EXPECT_FALSE(LS.empty()); 144 LexicalScope *FuncScope = LS.getCurrentFunctionScope(); 145 EXPECT_EQ(FuncScope->getParent(), nullptr); 146 EXPECT_EQ(FuncScope->getDesc(), OurFunc); 147 EXPECT_EQ(FuncScope->getInlinedAt(), nullptr); 148 EXPECT_EQ(FuncScope->getScopeNode(), OurFunc); 149 EXPECT_FALSE(FuncScope->isAbstractScope()); 150 EXPECT_EQ(FuncScope->getChildren().size(), 0u); 151 152 // There should be one range, covering the whole function. Test that it 153 // points at the correct instructions. 154 auto &Ranges = FuncScope->getRanges(); 155 ASSERT_EQ(Ranges.size(), 1u); 156 EXPECT_EQ(Ranges.front().first, &*MF->begin()->begin()); 157 auto BBIt = MF->end(); 158 BBIt = std::prev(BBIt); 159 EXPECT_EQ(Ranges.front().second, &*BBIt->begin()); 160 161 EXPECT_TRUE(FuncScope->dominates(FuncScope)); 162 SmallPtrSet<const MachineBasicBlock *, 4> MBBVec; 163 LS.getMachineBasicBlocks(OutermostLoc.get(), MBBVec); 164 165 EXPECT_EQ(MBBVec.size(), 4u); 166 // All the blocks should be in that set; the outermost loc should dominate 167 // them; and no other scope should. 168 for (auto &MBB : *MF) { 169 EXPECT_EQ(MBBVec.count(&MBB), 1u); 170 EXPECT_TRUE(LS.dominates(OutermostLoc.get(), &MBB)); 171 EXPECT_FALSE(LS.dominates(InBlockLoc.get(), &MBB)); 172 EXPECT_FALSE(LS.dominates(InlinedLoc.get(), &MBB)); 173 } 174 } 175 176 // Examine relationship between two nested scopes inside the function, the 177 // outer function and the lexical block within it. 178 TEST_F(LexicalScopesTest, BlockScopes) { 179 BuildMI(*MBB1, MBB1->end(), InBlockLoc, BeanInst); 180 BuildMI(*MBB2, MBB2->end(), InBlockLoc, BeanInst); 181 BuildMI(*MBB3, MBB3->end(), InBlockLoc, BeanInst); 182 BuildMI(*MBB4, MBB4->end(), InBlockLoc, BeanInst); 183 184 LexicalScopes LS; 185 LS.initialize(*MF); 186 LexicalScope *FuncScope = LS.getCurrentFunctionScope(); 187 EXPECT_EQ(FuncScope->getDesc(), OurFunc); 188 auto &Children = FuncScope->getChildren(); 189 ASSERT_EQ(Children.size(), 1u); 190 auto *BlockScope = Children[0]; 191 EXPECT_EQ(LS.findLexicalScope(InBlockLoc.get()), BlockScope); 192 EXPECT_EQ(BlockScope->getDesc(), InBlockLoc->getScope()); 193 EXPECT_FALSE(BlockScope->isAbstractScope()); 194 195 EXPECT_TRUE(FuncScope->dominates(BlockScope)); 196 EXPECT_FALSE(BlockScope->dominates(FuncScope)); 197 EXPECT_EQ(FuncScope->getParent(), nullptr); 198 EXPECT_EQ(BlockScope->getParent(), FuncScope); 199 200 SmallPtrSet<const MachineBasicBlock *, 4> MBBVec; 201 LS.getMachineBasicBlocks(OutermostLoc.get(), MBBVec); 202 203 EXPECT_EQ(MBBVec.size(), 4u); 204 for (auto &MBB : *MF) { 205 EXPECT_EQ(MBBVec.count(&MBB), 1u); 206 EXPECT_TRUE(LS.dominates(OutermostLoc.get(), &MBB)); 207 EXPECT_TRUE(LS.dominates(InBlockLoc.get(), &MBB)); 208 EXPECT_FALSE(LS.dominates(InlinedLoc.get(), &MBB)); 209 } 210 } 211 212 // Test inlined scopes functionality and relationship with the outer scopes. 213 TEST_F(LexicalScopesTest, InlinedScopes) { 214 BuildMI(*MBB1, MBB1->end(), InlinedLoc, BeanInst); 215 BuildMI(*MBB2, MBB2->end(), InlinedLoc, BeanInst); 216 BuildMI(*MBB3, MBB3->end(), InlinedLoc, BeanInst); 217 BuildMI(*MBB4, MBB4->end(), InlinedLoc, BeanInst); 218 219 LexicalScopes LS; 220 LS.initialize(*MF); 221 LexicalScope *FuncScope = LS.getCurrentFunctionScope(); 222 auto &Children = FuncScope->getChildren(); 223 ASSERT_EQ(Children.size(), 1u); 224 auto *BlockScope = Children[0]; 225 auto &BlockChildren = BlockScope->getChildren(); 226 ASSERT_EQ(BlockChildren.size(), 1u); 227 auto *InlinedScope = BlockChildren[0]; 228 229 EXPECT_FALSE(InlinedScope->isAbstractScope()); 230 EXPECT_EQ(InlinedScope->getInlinedAt(), InlinedLoc.getInlinedAt()); 231 EXPECT_EQ(InlinedScope->getDesc(), InlinedLoc.getScope()); 232 EXPECT_EQ(InlinedScope->getChildren().size(), 0u); 233 234 EXPECT_EQ(FuncScope->getParent(), nullptr); 235 EXPECT_EQ(BlockScope->getParent(), FuncScope); 236 EXPECT_EQ(InlinedScope->getParent(), BlockScope); 237 238 const auto &AbstractScopes = LS.getAbstractScopesList(); 239 ASSERT_EQ(AbstractScopes.size(), 1u); 240 const auto &AbstractScope = *AbstractScopes[0]; 241 EXPECT_TRUE(AbstractScope.isAbstractScope()); 242 EXPECT_EQ(AbstractScope.getDesc(), InlinedLoc.getScope()); 243 EXPECT_EQ(AbstractScope.getInlinedAt(), nullptr); 244 EXPECT_EQ(AbstractScope.getParent(), nullptr); 245 } 246 247 // Test behaviour in a function that has empty DebugLocs. 248 TEST_F(LexicalScopesTest, FuncWithEmptyGap) { 249 BuildMI(*MBB1, MBB1->end(), OutermostLoc, BeanInst); 250 BuildMI(*MBB2, MBB2->end(), DebugLoc(), BeanInst); 251 BuildMI(*MBB3, MBB3->end(), DebugLoc(), BeanInst); 252 BuildMI(*MBB4, MBB4->end(), OutermostLoc, BeanInst); 253 254 LexicalScopes LS; 255 LS.initialize(*MF); 256 LexicalScope *FuncScope = LS.getCurrentFunctionScope(); 257 258 // A gap in a range that contains no other location, is not actually a 259 // gap as far as lexical scopes are concerned. 260 auto &Ranges = FuncScope->getRanges(); 261 ASSERT_EQ(Ranges.size(), 1u); 262 EXPECT_EQ(Ranges[0].first, &*MF->begin()->begin()); 263 auto BBIt = MF->end(); 264 BBIt = std::prev(BBIt); 265 EXPECT_EQ(Ranges[0].second, &*BBIt->begin()); 266 } 267 268 // Now a function with intervening not-in-scope instructions. 269 TEST_F(LexicalScopesTest, FuncWithRealGap) { 270 MachineInstr *FirstI = BuildMI(*MBB1, MBB1->end(), InBlockLoc, BeanInst); 271 BuildMI(*MBB2, MBB2->end(), OutermostLoc, BeanInst); 272 BuildMI(*MBB3, MBB3->end(), OutermostLoc, BeanInst); 273 MachineInstr *LastI = BuildMI(*MBB4, MBB4->end(), InBlockLoc, BeanInst); 274 275 LexicalScopes LS; 276 LS.initialize(*MF); 277 LexicalScope *BlockScope = LS.findLexicalScope(InBlockLoc.get()); 278 ASSERT_NE(BlockScope, nullptr); 279 280 // Within the block scope, there's a gap between the first and last 281 // block / instruction, where it's only the outermost scope. 282 auto &Ranges = BlockScope->getRanges(); 283 ASSERT_EQ(Ranges.size(), 2u); 284 EXPECT_EQ(Ranges[0].first, FirstI); 285 EXPECT_EQ(Ranges[0].second, FirstI); 286 EXPECT_EQ(Ranges[1].first, LastI); 287 EXPECT_EQ(Ranges[1].second, LastI); 288 289 // The outer function scope should cover the whole function, including 290 // blocks the lexicalblock covers. 291 LexicalScope *FuncScope = LS.getCurrentFunctionScope(); 292 auto &FuncRanges = FuncScope->getRanges(); 293 ASSERT_EQ(FuncRanges.size(), 1u); 294 EXPECT_NE(FuncRanges[0].first, FuncRanges[0].second); 295 EXPECT_EQ(FuncRanges[0].first, FirstI); 296 EXPECT_EQ(FuncRanges[0].second, LastI); 297 } 298 299 // Examine the relationship between two scopes that don't nest (are siblings). 300 TEST_F(LexicalScopesTest, NotNested) { 301 MachineInstr *FirstI = BuildMI(*MBB1, MBB1->end(), InBlockLoc, BeanInst); 302 MachineInstr *SecondI = 303 BuildMI(*MBB2, MBB2->end(), NotNestedBlockLoc, BeanInst); 304 MachineInstr *ThirdI = 305 BuildMI(*MBB3, MBB3->end(), NotNestedBlockLoc, BeanInst); 306 MachineInstr *FourthI = BuildMI(*MBB4, MBB4->end(), InBlockLoc, BeanInst); 307 308 LexicalScopes LS; 309 LS.initialize(*MF); 310 LexicalScope *FuncScope = LS.getCurrentFunctionScope(); 311 LexicalScope *BlockScope = LS.findLexicalScope(InBlockLoc.get()); 312 LexicalScope *OtherBlockScope = LS.findLexicalScope(NotNestedBlockLoc.get()); 313 ASSERT_NE(FuncScope, nullptr); 314 ASSERT_NE(BlockScope, nullptr); 315 ASSERT_NE(OtherBlockScope, nullptr); 316 317 // The function should cover everything; the two blocks are distinct and 318 // should not. 319 auto &FuncRanges = FuncScope->getRanges(); 320 ASSERT_EQ(FuncRanges.size(), 1u); 321 EXPECT_EQ(FuncRanges[0].first, FirstI); 322 EXPECT_EQ(FuncRanges[0].second, FourthI); 323 324 // Two ranges, start and end instructions. 325 auto &BlockRanges = BlockScope->getRanges(); 326 ASSERT_EQ(BlockRanges.size(), 2u); 327 EXPECT_EQ(BlockRanges[0].first, FirstI); 328 EXPECT_EQ(BlockRanges[0].second, FirstI); 329 EXPECT_EQ(BlockRanges[1].first, FourthI); 330 EXPECT_EQ(BlockRanges[1].second, FourthI); 331 332 // One inner range, covering the two inner blocks. 333 auto &OtherBlockRanges = OtherBlockScope->getRanges(); 334 ASSERT_EQ(OtherBlockRanges.size(), 1u); 335 EXPECT_EQ(OtherBlockRanges[0].first, SecondI); 336 EXPECT_EQ(OtherBlockRanges[0].second, ThirdI); 337 } 338 339 // Test the scope-specific and block-specific dominates methods. 340 TEST_F(LexicalScopesTest, TestDominates) { 341 BuildMI(*MBB1, MBB1->end(), InBlockLoc, BeanInst); 342 BuildMI(*MBB2, MBB2->end(), NotNestedBlockLoc, BeanInst); 343 BuildMI(*MBB3, MBB3->end(), NotNestedBlockLoc, BeanInst); 344 BuildMI(*MBB4, MBB4->end(), InBlockLoc, BeanInst); 345 346 LexicalScopes LS; 347 LS.initialize(*MF); 348 LexicalScope *FuncScope = LS.getCurrentFunctionScope(); 349 LexicalScope *BlockScope = LS.findLexicalScope(InBlockLoc.get()); 350 LexicalScope *OtherBlockScope = LS.findLexicalScope(NotNestedBlockLoc.get()); 351 ASSERT_NE(FuncScope, nullptr); 352 ASSERT_NE(BlockScope, nullptr); 353 ASSERT_NE(OtherBlockScope, nullptr); 354 355 EXPECT_TRUE(FuncScope->dominates(BlockScope)); 356 EXPECT_TRUE(FuncScope->dominates(OtherBlockScope)); 357 EXPECT_FALSE(BlockScope->dominates(FuncScope)); 358 EXPECT_FALSE(BlockScope->dominates(OtherBlockScope)); 359 EXPECT_FALSE(OtherBlockScope->dominates(FuncScope)); 360 EXPECT_FALSE(OtherBlockScope->dominates(BlockScope)); 361 362 // Outermost scope dominates everything, as all insts are within it. 363 EXPECT_TRUE(LS.dominates(OutermostLoc.get(), MBB1)); 364 EXPECT_TRUE(LS.dominates(OutermostLoc.get(), MBB2)); 365 EXPECT_TRUE(LS.dominates(OutermostLoc.get(), MBB3)); 366 EXPECT_TRUE(LS.dominates(OutermostLoc.get(), MBB4)); 367 368 // One inner block dominates the outer pair of blocks, 369 EXPECT_TRUE(LS.dominates(InBlockLoc.get(), MBB1)); 370 EXPECT_FALSE(LS.dominates(InBlockLoc.get(), MBB2)); 371 EXPECT_FALSE(LS.dominates(InBlockLoc.get(), MBB3)); 372 EXPECT_TRUE(LS.dominates(InBlockLoc.get(), MBB4)); 373 374 // While the other dominates the inner two blocks. 375 EXPECT_FALSE(LS.dominates(NotNestedBlockLoc.get(), MBB1)); 376 EXPECT_TRUE(LS.dominates(NotNestedBlockLoc.get(), MBB2)); 377 EXPECT_TRUE(LS.dominates(NotNestedBlockLoc.get(), MBB3)); 378 EXPECT_FALSE(LS.dominates(NotNestedBlockLoc.get(), MBB4)); 379 } 380 381 // Test getMachineBasicBlocks returns all dominated blocks. 382 TEST_F(LexicalScopesTest, TestGetBlocks) { 383 BuildMI(*MBB1, MBB1->end(), InBlockLoc, BeanInst); 384 BuildMI(*MBB2, MBB2->end(), NotNestedBlockLoc, BeanInst); 385 BuildMI(*MBB3, MBB3->end(), NotNestedBlockLoc, BeanInst); 386 BuildMI(*MBB4, MBB4->end(), InBlockLoc, BeanInst); 387 388 LexicalScopes LS; 389 LS.initialize(*MF); 390 LexicalScope *FuncScope = LS.getCurrentFunctionScope(); 391 LexicalScope *BlockScope = LS.findLexicalScope(InBlockLoc.get()); 392 LexicalScope *OtherBlockScope = LS.findLexicalScope(NotNestedBlockLoc.get()); 393 ASSERT_NE(FuncScope, nullptr); 394 ASSERT_NE(BlockScope, nullptr); 395 ASSERT_NE(OtherBlockScope, nullptr); 396 397 SmallPtrSet<const MachineBasicBlock *, 4> OutermostBlocks, InBlockBlocks, 398 NotNestedBlockBlocks; 399 LS.getMachineBasicBlocks(OutermostLoc.get(), OutermostBlocks); 400 LS.getMachineBasicBlocks(InBlockLoc.get(), InBlockBlocks); 401 LS.getMachineBasicBlocks(NotNestedBlockLoc.get(), NotNestedBlockBlocks); 402 403 EXPECT_EQ(OutermostBlocks.count(MBB1), 1u); 404 EXPECT_EQ(OutermostBlocks.count(MBB2), 1u); 405 EXPECT_EQ(OutermostBlocks.count(MBB3), 1u); 406 EXPECT_EQ(OutermostBlocks.count(MBB4), 1u); 407 408 EXPECT_EQ(InBlockBlocks.count(MBB1), 1u); 409 EXPECT_EQ(InBlockBlocks.count(MBB2), 0u); 410 EXPECT_EQ(InBlockBlocks.count(MBB3), 0u); 411 EXPECT_EQ(InBlockBlocks.count(MBB4), 1u); 412 413 EXPECT_EQ(NotNestedBlockBlocks.count(MBB1), 0u); 414 EXPECT_EQ(NotNestedBlockBlocks.count(MBB2), 1u); 415 EXPECT_EQ(NotNestedBlockBlocks.count(MBB3), 1u); 416 EXPECT_EQ(NotNestedBlockBlocks.count(MBB4), 0u); 417 } 418 419 TEST_F(LexicalScopesTest, TestMetaInst) { 420 // Instruction Layout looks like this, where 'F' means funcscope, and 421 // 'B' blockscope: 422 // bb1: 423 // F: bean 424 // B: bean 425 // bb2: 426 // F: bean 427 // B: DBG_VALUE 428 // bb3: 429 // F: bean 430 // B: DBG_VALUE 431 // bb4: 432 // F: bean 433 // B: bean 434 // The block / 'B' should only dominate bb1 and bb4. DBG_VALUE is a meta 435 // instruction, and shouldn't contribute to scopes. 436 BuildMI(*MBB1, MBB1->end(), OutermostLoc, BeanInst); 437 BuildMI(*MBB1, MBB1->end(), InBlockLoc, BeanInst); 438 BuildMI(*MBB2, MBB2->end(), OutermostLoc, BeanInst); 439 BuildMI(*MBB2, MBB2->end(), InBlockLoc, DbgValueInst); 440 BuildMI(*MBB3, MBB3->end(), OutermostLoc, BeanInst); 441 BuildMI(*MBB3, MBB3->end(), InBlockLoc, DbgValueInst); 442 BuildMI(*MBB4, MBB4->end(), OutermostLoc, BeanInst); 443 BuildMI(*MBB4, MBB4->end(), InBlockLoc, BeanInst); 444 445 LexicalScopes LS; 446 LS.initialize(*MF); 447 LexicalScope *FuncScope = LS.getCurrentFunctionScope(); 448 LexicalScope *BlockScope = LS.findLexicalScope(InBlockLoc.get()); 449 ASSERT_NE(FuncScope, nullptr); 450 ASSERT_NE(BlockScope, nullptr); 451 452 EXPECT_TRUE(LS.dominates(OutermostLoc.get(), MBB1)); 453 EXPECT_TRUE(LS.dominates(OutermostLoc.get(), MBB2)); 454 EXPECT_TRUE(LS.dominates(OutermostLoc.get(), MBB3)); 455 EXPECT_TRUE(LS.dominates(OutermostLoc.get(), MBB4)); 456 EXPECT_TRUE(LS.dominates(InBlockLoc.get(), MBB1)); 457 EXPECT_FALSE(LS.dominates(InBlockLoc.get(), MBB2)); 458 EXPECT_FALSE(LS.dominates(InBlockLoc.get(), MBB3)); 459 EXPECT_TRUE(LS.dominates(InBlockLoc.get(), MBB4)); 460 } 461 462 } // anonymous namespace 463