1 //===- llvm/unittests/tools/llvm-cfi-verify/FileAnalysis.cpp --------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "../tools/llvm-cfi-verify/lib/FileAnalysis.h" 11 #include "gmock/gmock.h" 12 #include "gtest/gtest.h" 13 14 #include "llvm/BinaryFormat/ELF.h" 15 #include "llvm/MC/MCAsmInfo.h" 16 #include "llvm/MC/MCContext.h" 17 #include "llvm/MC/MCDisassembler/MCDisassembler.h" 18 #include "llvm/MC/MCInst.h" 19 #include "llvm/MC/MCInstPrinter.h" 20 #include "llvm/MC/MCInstrAnalysis.h" 21 #include "llvm/MC/MCInstrDesc.h" 22 #include "llvm/MC/MCInstrInfo.h" 23 #include "llvm/MC/MCObjectFileInfo.h" 24 #include "llvm/MC/MCRegisterInfo.h" 25 #include "llvm/MC/MCSubtargetInfo.h" 26 #include "llvm/Object/Binary.h" 27 #include "llvm/Object/COFF.h" 28 #include "llvm/Object/ELFObjectFile.h" 29 #include "llvm/Object/ObjectFile.h" 30 #include "llvm/Support/Casting.h" 31 #include "llvm/Support/CommandLine.h" 32 #include "llvm/Support/Error.h" 33 #include "llvm/Support/MemoryBuffer.h" 34 #include "llvm/Support/TargetRegistry.h" 35 #include "llvm/Support/TargetSelect.h" 36 #include "llvm/Support/raw_ostream.h" 37 38 #include <cstdlib> 39 40 using Instr = ::llvm::cfi_verify::FileAnalysis::Instr; 41 using ::testing::Eq; 42 using ::testing::Field; 43 44 namespace llvm { 45 namespace cfi_verify { 46 namespace { 47 class ELFx86TestFileAnalysis : public FileAnalysis { 48 public: 49 ELFx86TestFileAnalysis() 50 : FileAnalysis(Triple("x86_64--"), SubtargetFeatures()) {} 51 52 // Expose this method publicly for testing. 53 void parseSectionContents(ArrayRef<uint8_t> SectionBytes, 54 uint64_t SectionAddress) { 55 FileAnalysis::parseSectionContents(SectionBytes, SectionAddress); 56 } 57 58 Error initialiseDisassemblyMembers() { 59 return FileAnalysis::initialiseDisassemblyMembers(); 60 } 61 }; 62 63 class BasicFileAnalysisTest : public ::testing::Test { 64 protected: 65 virtual void SetUp() { 66 SuccessfullyInitialised = true; 67 if (auto Err = Analysis.initialiseDisassemblyMembers()) { 68 handleAllErrors(std::move(Err), [&](const UnsupportedDisassembly &E) { 69 SuccessfullyInitialised = false; 70 outs() 71 << "Note: CFIVerifyTests are disabled due to lack of x86 support " 72 "on this build.\n"; 73 }); 74 } 75 } 76 77 bool SuccessfullyInitialised; 78 ELFx86TestFileAnalysis Analysis; 79 }; 80 81 TEST_F(BasicFileAnalysisTest, BasicDisassemblyTraversalTest) { 82 if (!SuccessfullyInitialised) 83 return; 84 Analysis.parseSectionContents( 85 { 86 0x90, // 0: nop 87 0xb0, 0x00, // 1: mov $0x0, %al 88 0x48, 0x89, 0xe5, // 3: mov %rsp, %rbp 89 0x48, 0x83, 0xec, 0x18, // 6: sub $0x18, %rsp 90 0x48, 0xbe, 0xc4, 0x07, 0x40, 91 0x00, 0x00, 0x00, 0x00, 0x00, // 10: movabs $0x4007c4, %rsi 92 0x2f, // 20: (bad) 93 0x41, 0x0e, // 21: rex.B (bad) 94 0x62, 0x72, 0x65, 0x61, 0x6b, // 23: (bad) {%k1} 95 }, 96 0xDEADBEEF); 97 98 EXPECT_EQ(nullptr, Analysis.getInstruction(0x0)); 99 EXPECT_EQ(nullptr, Analysis.getInstruction(0x1000)); 100 101 // 0xDEADBEEF: nop 102 const auto *InstrMeta = Analysis.getInstruction(0xDEADBEEF); 103 EXPECT_NE(nullptr, InstrMeta); 104 EXPECT_EQ(0xDEADBEEF, InstrMeta->VMAddress); 105 EXPECT_EQ(1u, InstrMeta->InstructionSize); 106 EXPECT_TRUE(InstrMeta->Valid); 107 108 const auto *NextInstrMeta = Analysis.getNextInstructionSequential(*InstrMeta); 109 EXPECT_EQ(nullptr, Analysis.getPrevInstructionSequential(*InstrMeta)); 110 const auto *PrevInstrMeta = InstrMeta; 111 112 // 0xDEADBEEF + 1: mov $0x0, %al 113 InstrMeta = Analysis.getInstruction(0xDEADBEEF + 1); 114 EXPECT_NE(nullptr, InstrMeta); 115 EXPECT_EQ(NextInstrMeta, InstrMeta); 116 EXPECT_EQ(0xDEADBEEF + 1, InstrMeta->VMAddress); 117 EXPECT_EQ(2u, InstrMeta->InstructionSize); 118 EXPECT_TRUE(InstrMeta->Valid); 119 120 NextInstrMeta = Analysis.getNextInstructionSequential(*InstrMeta); 121 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta)); 122 PrevInstrMeta = InstrMeta; 123 124 // 0xDEADBEEF + 3: mov %rsp, %rbp 125 InstrMeta = Analysis.getInstruction(0xDEADBEEF + 3); 126 EXPECT_NE(nullptr, InstrMeta); 127 EXPECT_EQ(NextInstrMeta, InstrMeta); 128 EXPECT_EQ(0xDEADBEEF + 3, InstrMeta->VMAddress); 129 EXPECT_EQ(3u, InstrMeta->InstructionSize); 130 EXPECT_TRUE(InstrMeta->Valid); 131 132 NextInstrMeta = Analysis.getNextInstructionSequential(*InstrMeta); 133 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta)); 134 PrevInstrMeta = InstrMeta; 135 136 // 0xDEADBEEF + 6: sub $0x18, %rsp 137 InstrMeta = Analysis.getInstruction(0xDEADBEEF + 6); 138 EXPECT_NE(nullptr, InstrMeta); 139 EXPECT_EQ(NextInstrMeta, InstrMeta); 140 EXPECT_EQ(0xDEADBEEF + 6, InstrMeta->VMAddress); 141 EXPECT_EQ(4u, InstrMeta->InstructionSize); 142 EXPECT_TRUE(InstrMeta->Valid); 143 144 NextInstrMeta = Analysis.getNextInstructionSequential(*InstrMeta); 145 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta)); 146 PrevInstrMeta = InstrMeta; 147 148 // 0xDEADBEEF + 10: movabs $0x4007c4, %rsi 149 InstrMeta = Analysis.getInstruction(0xDEADBEEF + 10); 150 EXPECT_NE(nullptr, InstrMeta); 151 EXPECT_EQ(NextInstrMeta, InstrMeta); 152 EXPECT_EQ(0xDEADBEEF + 10, InstrMeta->VMAddress); 153 EXPECT_EQ(10u, InstrMeta->InstructionSize); 154 EXPECT_TRUE(InstrMeta->Valid); 155 156 EXPECT_EQ(nullptr, Analysis.getNextInstructionSequential(*InstrMeta)); 157 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta)); 158 PrevInstrMeta = InstrMeta; 159 160 // 0xDEADBEEF + 20: (bad) 161 InstrMeta = Analysis.getInstruction(0xDEADBEEF + 20); 162 EXPECT_NE(nullptr, InstrMeta); 163 EXPECT_EQ(0xDEADBEEF + 20, InstrMeta->VMAddress); 164 EXPECT_EQ(1u, InstrMeta->InstructionSize); 165 EXPECT_FALSE(InstrMeta->Valid); 166 167 EXPECT_EQ(nullptr, Analysis.getNextInstructionSequential(*InstrMeta)); 168 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta)); 169 170 // 0xDEADBEEF + 21: rex.B (bad) 171 InstrMeta = Analysis.getInstruction(0xDEADBEEF + 21); 172 EXPECT_NE(nullptr, InstrMeta); 173 EXPECT_EQ(0xDEADBEEF + 21, InstrMeta->VMAddress); 174 EXPECT_EQ(2u, InstrMeta->InstructionSize); 175 EXPECT_FALSE(InstrMeta->Valid); 176 177 EXPECT_EQ(nullptr, Analysis.getNextInstructionSequential(*InstrMeta)); 178 EXPECT_EQ(nullptr, Analysis.getPrevInstructionSequential(*InstrMeta)); 179 180 // 0xDEADBEEF + 6: (bad) {%k1} 181 InstrMeta = Analysis.getInstruction(0xDEADBEEF + 23); 182 EXPECT_NE(nullptr, InstrMeta); 183 EXPECT_EQ(0xDEADBEEF + 23, InstrMeta->VMAddress); 184 EXPECT_EQ(5u, InstrMeta->InstructionSize); 185 EXPECT_FALSE(InstrMeta->Valid); 186 187 EXPECT_EQ(nullptr, Analysis.getNextInstructionSequential(*InstrMeta)); 188 EXPECT_EQ(nullptr, Analysis.getPrevInstructionSequential(*InstrMeta)); 189 } 190 191 TEST_F(BasicFileAnalysisTest, PrevAndNextFromBadInst) { 192 if (!SuccessfullyInitialised) 193 return; 194 Analysis.parseSectionContents( 195 { 196 0x90, // 0: nop 197 0x2f, // 1: (bad) 198 0x90 // 2: nop 199 }, 200 0xDEADBEEF); 201 const auto &BadInstrMeta = Analysis.getInstructionOrDie(0xDEADBEEF + 1); 202 const auto *GoodInstrMeta = 203 Analysis.getPrevInstructionSequential(BadInstrMeta); 204 EXPECT_NE(nullptr, GoodInstrMeta); 205 EXPECT_EQ(0xDEADBEEF, GoodInstrMeta->VMAddress); 206 EXPECT_EQ(1u, GoodInstrMeta->InstructionSize); 207 208 GoodInstrMeta = Analysis.getNextInstructionSequential(BadInstrMeta); 209 EXPECT_NE(nullptr, GoodInstrMeta); 210 EXPECT_EQ(0xDEADBEEF + 2, GoodInstrMeta->VMAddress); 211 EXPECT_EQ(1u, GoodInstrMeta->InstructionSize); 212 } 213 214 TEST_F(BasicFileAnalysisTest, CFITrapTest) { 215 if (!SuccessfullyInitialised) 216 return; 217 Analysis.parseSectionContents( 218 { 219 0x90, // 0: nop 220 0xb0, 0x00, // 1: mov $0x0, %al 221 0x48, 0x89, 0xe5, // 3: mov %rsp, %rbp 222 0x48, 0x83, 0xec, 0x18, // 6: sub $0x18, %rsp 223 0x48, 0xbe, 0xc4, 0x07, 0x40, 224 0x00, 0x00, 0x00, 0x00, 0x00, // 10: movabs $0x4007c4, %rsi 225 0x2f, // 20: (bad) 226 0x41, 0x0e, // 21: rex.B (bad) 227 0x62, 0x72, 0x65, 0x61, 0x6b, // 23: (bad) {%k1} 228 0x0f, 0x0b // 28: ud2 229 }, 230 0xDEADBEEF); 231 232 EXPECT_FALSE(Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF))); 233 EXPECT_FALSE( 234 Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 3))); 235 EXPECT_FALSE( 236 Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 6))); 237 EXPECT_FALSE( 238 Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 10))); 239 EXPECT_FALSE( 240 Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 20))); 241 EXPECT_FALSE( 242 Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 21))); 243 EXPECT_FALSE( 244 Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 23))); 245 EXPECT_TRUE( 246 Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 28))); 247 } 248 249 TEST_F(BasicFileAnalysisTest, FallThroughTest) { 250 if (!SuccessfullyInitialised) 251 return; 252 Analysis.parseSectionContents( 253 { 254 0x90, // 0: nop 255 0xb0, 0x00, // 1: mov $0x0, %al 256 0x2f, // 3: (bad) 257 0x0f, 0x0b, // 4: ud2 258 0xff, 0x20, // 6: jmpq *(%rax) 259 0xeb, 0x00, // 8: jmp +0 260 0xe8, 0x45, 0xfe, 0xff, 0xff, // 10: callq [some loc] 261 0xff, 0x10, // 15: callq *(rax) 262 0x75, 0x00, // 17: jne +0 263 0xc3, // 19: retq 264 }, 265 0xDEADBEEF); 266 267 EXPECT_TRUE( 268 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF))); 269 EXPECT_TRUE( 270 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 1))); 271 EXPECT_FALSE( 272 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 3))); 273 EXPECT_FALSE( 274 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 4))); 275 EXPECT_FALSE( 276 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 6))); 277 EXPECT_FALSE( 278 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 8))); 279 EXPECT_FALSE( 280 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 10))); 281 EXPECT_FALSE( 282 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 15))); 283 EXPECT_TRUE( 284 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 17))); 285 EXPECT_FALSE( 286 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 19))); 287 } 288 289 TEST_F(BasicFileAnalysisTest, DefiniteNextInstructionTest) { 290 if (!SuccessfullyInitialised) 291 return; 292 Analysis.parseSectionContents( 293 { 294 0x90, // 0: nop 295 0xb0, 0x00, // 1: mov $0x0, %al 296 0x2f, // 3: (bad) 297 0x0f, 0x0b, // 4: ud2 298 0xff, 0x20, // 6: jmpq *(%rax) 299 0xeb, 0x00, // 8: jmp 10 [+0] 300 0xeb, 0x05, // 10: jmp 17 [+5] 301 0xe8, 0x00, 0x00, 0x00, 0x00, // 12: callq 17 [+0] 302 0xe8, 0x78, 0x56, 0x34, 0x12, // 17: callq 0x1234569f [+0x12345678] 303 0xe8, 0x04, 0x00, 0x00, 0x00, // 22: callq 31 [+4] 304 0xff, 0x10, // 27: callq *(rax) 305 0x75, 0x00, // 29: jne 31 [+0] 306 0x75, 0xe0, // 31: jne 1 [-32] 307 0xc3, // 33: retq 308 0xeb, 0xdd, // 34: jmp 1 [-35] 309 0xeb, 0xdd, // 36: jmp 3 [-35] 310 0xeb, 0xdc, // 38: jmp 4 [-36] 311 }, 312 0xDEADBEEF); 313 314 const auto *Current = Analysis.getInstruction(0xDEADBEEF); 315 const auto *Next = Analysis.getDefiniteNextInstruction(*Current); 316 EXPECT_NE(nullptr, Next); 317 EXPECT_EQ(0xDEADBEEF + 1, Next->VMAddress); 318 319 Current = Analysis.getInstruction(0xDEADBEEF + 1); 320 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 321 322 Current = Analysis.getInstruction(0xDEADBEEF + 3); 323 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 324 325 Current = Analysis.getInstruction(0xDEADBEEF + 4); 326 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 327 328 Current = Analysis.getInstruction(0xDEADBEEF + 6); 329 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 330 331 Current = Analysis.getInstruction(0xDEADBEEF + 8); 332 Next = Analysis.getDefiniteNextInstruction(*Current); 333 EXPECT_NE(nullptr, Next); 334 EXPECT_EQ(0xDEADBEEF + 10, Next->VMAddress); 335 336 Current = Analysis.getInstruction(0xDEADBEEF + 10); 337 Next = Analysis.getDefiniteNextInstruction(*Current); 338 EXPECT_NE(nullptr, Next); 339 EXPECT_EQ(0xDEADBEEF + 17, Next->VMAddress); 340 341 Current = Analysis.getInstruction(0xDEADBEEF + 12); 342 Next = Analysis.getDefiniteNextInstruction(*Current); 343 EXPECT_NE(nullptr, Next); 344 EXPECT_EQ(0xDEADBEEF + 17, Next->VMAddress); 345 346 Current = Analysis.getInstruction(0xDEADBEEF + 17); 347 // Note, definite next instruction address is out of range and should fail. 348 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 349 Next = Analysis.getDefiniteNextInstruction(*Current); 350 351 Current = Analysis.getInstruction(0xDEADBEEF + 22); 352 Next = Analysis.getDefiniteNextInstruction(*Current); 353 EXPECT_NE(nullptr, Next); 354 EXPECT_EQ(0xDEADBEEF + 31, Next->VMAddress); 355 356 Current = Analysis.getInstruction(0xDEADBEEF + 27); 357 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 358 Current = Analysis.getInstruction(0xDEADBEEF + 29); 359 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 360 Current = Analysis.getInstruction(0xDEADBEEF + 31); 361 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 362 Current = Analysis.getInstruction(0xDEADBEEF + 33); 363 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 364 365 Current = Analysis.getInstruction(0xDEADBEEF + 34); 366 Next = Analysis.getDefiniteNextInstruction(*Current); 367 EXPECT_NE(nullptr, Next); 368 EXPECT_EQ(0xDEADBEEF + 1, Next->VMAddress); 369 370 Current = Analysis.getInstruction(0xDEADBEEF + 36); 371 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 372 373 Current = Analysis.getInstruction(0xDEADBEEF + 38); 374 Next = Analysis.getDefiniteNextInstruction(*Current); 375 EXPECT_NE(nullptr, Next); 376 EXPECT_EQ(0xDEADBEEF + 4, Next->VMAddress); 377 } 378 379 TEST_F(BasicFileAnalysisTest, ControlFlowXRefsTest) { 380 if (!SuccessfullyInitialised) 381 return; 382 Analysis.parseSectionContents( 383 { 384 0x90, // 0: nop 385 0xb0, 0x00, // 1: mov $0x0, %al 386 0x2f, // 3: (bad) 387 0x0f, 0x0b, // 4: ud2 388 0xff, 0x20, // 6: jmpq *(%rax) 389 0xeb, 0x00, // 8: jmp 10 [+0] 390 0xeb, 0x05, // 10: jmp 17 [+5] 391 0xe8, 0x00, 0x00, 0x00, 0x00, // 12: callq 17 [+0] 392 0xe8, 0x78, 0x56, 0x34, 0x12, // 17: callq 0x1234569f [+0x12345678] 393 0xe8, 0x04, 0x00, 0x00, 0x00, // 22: callq 31 [+4] 394 0xff, 0x10, // 27: callq *(rax) 395 0x75, 0x00, // 29: jne 31 [+0] 396 0x75, 0xe0, // 31: jne 1 [-32] 397 0xc3, // 33: retq 398 0xeb, 0xdd, // 34: jmp 1 [-35] 399 0xeb, 0xdd, // 36: jmp 3 [-35] 400 0xeb, 0xdc, // 38: jmp 4 [-36] 401 }, 402 0xDEADBEEF); 403 const auto *InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF); 404 std::set<const Instr *> XRefs = 405 Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 406 EXPECT_TRUE(XRefs.empty()); 407 408 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 1); 409 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 410 EXPECT_THAT(XRefs, UnorderedElementsAre( 411 Field(&Instr::VMAddress, Eq(0xDEADBEEF)), 412 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 31)), 413 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 34)))); 414 415 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 3); 416 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 417 EXPECT_THAT(XRefs, UnorderedElementsAre( 418 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 1)), 419 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 36)))); 420 421 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 4); 422 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 423 EXPECT_THAT(XRefs, UnorderedElementsAre( 424 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 38)))); 425 426 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 6); 427 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 428 429 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 8); 430 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 431 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 432 433 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 10); 434 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 435 EXPECT_THAT(XRefs, UnorderedElementsAre( 436 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 8)))); 437 438 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 12); 439 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 440 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 441 442 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 17); 443 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 444 EXPECT_THAT(XRefs, UnorderedElementsAre( 445 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 10)), 446 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 12)))); 447 448 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 22); 449 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 450 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 451 452 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 27); 453 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 454 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 455 456 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 29); 457 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 458 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 459 460 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 31); 461 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 462 EXPECT_THAT(XRefs, UnorderedElementsAre( 463 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 22)), 464 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 29)))); 465 466 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 33); 467 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 468 EXPECT_THAT(XRefs, UnorderedElementsAre( 469 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 31)))); 470 471 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 34); 472 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 473 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 474 475 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 36); 476 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 477 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 478 479 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 38); 480 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 481 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 482 } 483 484 } // anonymous namespace 485 } // end namespace cfi_verify 486 } // end namespace llvm 487 488 int main(int argc, char **argv) { 489 ::testing::InitGoogleTest(&argc, argv); 490 llvm::cl::ParseCommandLineOptions(argc, argv); 491 492 llvm::InitializeAllTargetInfos(); 493 llvm::InitializeAllTargetMCs(); 494 llvm::InitializeAllAsmParsers(); 495 llvm::InitializeAllDisassemblers(); 496 497 return RUN_ALL_TESTS(); 498 } 499