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 if (Analysis.initialiseDisassemblyMembers()) { 67 FAIL() << "Failed to initialise FileAnalysis."; 68 } 69 } 70 71 ELFx86TestFileAnalysis Analysis; 72 }; 73 74 TEST_F(BasicFileAnalysisTest, BasicDisassemblyTraversalTest) { 75 Analysis.parseSectionContents( 76 { 77 0x90, // 0: nop 78 0xb0, 0x00, // 1: mov $0x0, %al 79 0x48, 0x89, 0xe5, // 3: mov %rsp, %rbp 80 0x48, 0x83, 0xec, 0x18, // 6: sub $0x18, %rsp 81 0x48, 0xbe, 0xc4, 0x07, 0x40, 82 0x00, 0x00, 0x00, 0x00, 0x00, // 10: movabs $0x4007c4, %rsi 83 0x2f, // 20: (bad) 84 0x41, 0x0e, // 21: rex.B (bad) 85 0x62, 0x72, 0x65, 0x61, 0x6b, // 23: (bad) {%k1} 86 }, 87 0xDEADBEEF); 88 89 EXPECT_EQ(nullptr, Analysis.getInstruction(0x0)); 90 EXPECT_EQ(nullptr, Analysis.getInstruction(0x1000)); 91 92 // 0xDEADBEEF: nop 93 const auto *InstrMeta = Analysis.getInstruction(0xDEADBEEF); 94 EXPECT_NE(nullptr, InstrMeta); 95 EXPECT_EQ(0xDEADBEEF, InstrMeta->VMAddress); 96 EXPECT_EQ(1u, InstrMeta->InstructionSize); 97 EXPECT_TRUE(InstrMeta->Valid); 98 99 const auto *NextInstrMeta = Analysis.getNextInstructionSequential(*InstrMeta); 100 EXPECT_EQ(nullptr, Analysis.getPrevInstructionSequential(*InstrMeta)); 101 const auto *PrevInstrMeta = InstrMeta; 102 103 // 0xDEADBEEF + 1: mov $0x0, %al 104 InstrMeta = Analysis.getInstruction(0xDEADBEEF + 1); 105 EXPECT_NE(nullptr, InstrMeta); 106 EXPECT_EQ(NextInstrMeta, InstrMeta); 107 EXPECT_EQ(0xDEADBEEF + 1, InstrMeta->VMAddress); 108 EXPECT_EQ(2u, InstrMeta->InstructionSize); 109 EXPECT_TRUE(InstrMeta->Valid); 110 111 NextInstrMeta = Analysis.getNextInstructionSequential(*InstrMeta); 112 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta)); 113 PrevInstrMeta = InstrMeta; 114 115 // 0xDEADBEEF + 3: mov %rsp, %rbp 116 InstrMeta = Analysis.getInstruction(0xDEADBEEF + 3); 117 EXPECT_NE(nullptr, InstrMeta); 118 EXPECT_EQ(NextInstrMeta, InstrMeta); 119 EXPECT_EQ(0xDEADBEEF + 3, InstrMeta->VMAddress); 120 EXPECT_EQ(3u, InstrMeta->InstructionSize); 121 EXPECT_TRUE(InstrMeta->Valid); 122 123 NextInstrMeta = Analysis.getNextInstructionSequential(*InstrMeta); 124 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta)); 125 PrevInstrMeta = InstrMeta; 126 127 // 0xDEADBEEF + 6: sub $0x18, %rsp 128 InstrMeta = Analysis.getInstruction(0xDEADBEEF + 6); 129 EXPECT_NE(nullptr, InstrMeta); 130 EXPECT_EQ(NextInstrMeta, InstrMeta); 131 EXPECT_EQ(0xDEADBEEF + 6, InstrMeta->VMAddress); 132 EXPECT_EQ(4u, InstrMeta->InstructionSize); 133 EXPECT_TRUE(InstrMeta->Valid); 134 135 NextInstrMeta = Analysis.getNextInstructionSequential(*InstrMeta); 136 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta)); 137 PrevInstrMeta = InstrMeta; 138 139 // 0xDEADBEEF + 10: movabs $0x4007c4, %rsi 140 InstrMeta = Analysis.getInstruction(0xDEADBEEF + 10); 141 EXPECT_NE(nullptr, InstrMeta); 142 EXPECT_EQ(NextInstrMeta, InstrMeta); 143 EXPECT_EQ(0xDEADBEEF + 10, InstrMeta->VMAddress); 144 EXPECT_EQ(10u, InstrMeta->InstructionSize); 145 EXPECT_TRUE(InstrMeta->Valid); 146 147 EXPECT_EQ(nullptr, Analysis.getNextInstructionSequential(*InstrMeta)); 148 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta)); 149 PrevInstrMeta = InstrMeta; 150 151 // 0xDEADBEEF + 20: (bad) 152 InstrMeta = Analysis.getInstruction(0xDEADBEEF + 20); 153 EXPECT_NE(nullptr, InstrMeta); 154 EXPECT_EQ(0xDEADBEEF + 20, InstrMeta->VMAddress); 155 EXPECT_EQ(1u, InstrMeta->InstructionSize); 156 EXPECT_FALSE(InstrMeta->Valid); 157 158 EXPECT_EQ(nullptr, Analysis.getNextInstructionSequential(*InstrMeta)); 159 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta)); 160 161 // 0xDEADBEEF + 21: rex.B (bad) 162 InstrMeta = Analysis.getInstruction(0xDEADBEEF + 21); 163 EXPECT_NE(nullptr, InstrMeta); 164 EXPECT_EQ(0xDEADBEEF + 21, InstrMeta->VMAddress); 165 EXPECT_EQ(2u, InstrMeta->InstructionSize); 166 EXPECT_FALSE(InstrMeta->Valid); 167 168 EXPECT_EQ(nullptr, Analysis.getNextInstructionSequential(*InstrMeta)); 169 EXPECT_EQ(nullptr, Analysis.getPrevInstructionSequential(*InstrMeta)); 170 171 // 0xDEADBEEF + 6: (bad) {%k1} 172 InstrMeta = Analysis.getInstruction(0xDEADBEEF + 23); 173 EXPECT_NE(nullptr, InstrMeta); 174 EXPECT_EQ(0xDEADBEEF + 23, InstrMeta->VMAddress); 175 EXPECT_EQ(5u, InstrMeta->InstructionSize); 176 EXPECT_FALSE(InstrMeta->Valid); 177 178 EXPECT_EQ(nullptr, Analysis.getNextInstructionSequential(*InstrMeta)); 179 EXPECT_EQ(nullptr, Analysis.getPrevInstructionSequential(*InstrMeta)); 180 } 181 182 TEST_F(BasicFileAnalysisTest, PrevAndNextFromBadInst) { 183 Analysis.parseSectionContents( 184 { 185 0x90, // 0: nop 186 0x2f, // 1: (bad) 187 0x90 // 2: nop 188 }, 189 0xDEADBEEF); 190 const auto &BadInstrMeta = Analysis.getInstructionOrDie(0xDEADBEEF + 1); 191 const auto *GoodInstrMeta = 192 Analysis.getPrevInstructionSequential(BadInstrMeta); 193 EXPECT_NE(nullptr, GoodInstrMeta); 194 EXPECT_EQ(0xDEADBEEF, GoodInstrMeta->VMAddress); 195 EXPECT_EQ(1u, GoodInstrMeta->InstructionSize); 196 197 GoodInstrMeta = Analysis.getNextInstructionSequential(BadInstrMeta); 198 EXPECT_NE(nullptr, GoodInstrMeta); 199 EXPECT_EQ(0xDEADBEEF + 2, GoodInstrMeta->VMAddress); 200 EXPECT_EQ(1u, GoodInstrMeta->InstructionSize); 201 } 202 203 TEST_F(BasicFileAnalysisTest, CFITrapTest) { 204 Analysis.parseSectionContents( 205 { 206 0x90, // 0: nop 207 0xb0, 0x00, // 1: mov $0x0, %al 208 0x48, 0x89, 0xe5, // 3: mov %rsp, %rbp 209 0x48, 0x83, 0xec, 0x18, // 6: sub $0x18, %rsp 210 0x48, 0xbe, 0xc4, 0x07, 0x40, 211 0x00, 0x00, 0x00, 0x00, 0x00, // 10: movabs $0x4007c4, %rsi 212 0x2f, // 20: (bad) 213 0x41, 0x0e, // 21: rex.B (bad) 214 0x62, 0x72, 0x65, 0x61, 0x6b, // 23: (bad) {%k1} 215 0x0f, 0x0b // 28: ud2 216 }, 217 0xDEADBEEF); 218 219 EXPECT_FALSE(Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF))); 220 EXPECT_FALSE( 221 Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 3))); 222 EXPECT_FALSE( 223 Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 6))); 224 EXPECT_FALSE( 225 Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 10))); 226 EXPECT_FALSE( 227 Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 20))); 228 EXPECT_FALSE( 229 Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 21))); 230 EXPECT_FALSE( 231 Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 23))); 232 EXPECT_TRUE( 233 Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 28))); 234 } 235 236 TEST_F(BasicFileAnalysisTest, FallThroughTest) { 237 Analysis.parseSectionContents( 238 { 239 0x90, // 0: nop 240 0xb0, 0x00, // 1: mov $0x0, %al 241 0x2f, // 3: (bad) 242 0x0f, 0x0b, // 4: ud2 243 0xff, 0x20, // 6: jmpq *(%rax) 244 0xeb, 0x00, // 8: jmp +0 245 0xe8, 0x45, 0xfe, 0xff, 0xff, // 10: callq [some loc] 246 0xff, 0x10, // 15: callq *(rax) 247 0x75, 0x00, // 17: jne +0 248 0xc3, // 19: retq 249 }, 250 0xDEADBEEF); 251 252 EXPECT_TRUE( 253 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF))); 254 EXPECT_TRUE( 255 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 1))); 256 EXPECT_FALSE( 257 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 3))); 258 EXPECT_FALSE( 259 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 4))); 260 EXPECT_FALSE( 261 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 6))); 262 EXPECT_FALSE( 263 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 8))); 264 EXPECT_FALSE( 265 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 10))); 266 EXPECT_FALSE( 267 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 15))); 268 EXPECT_TRUE( 269 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 17))); 270 EXPECT_FALSE( 271 Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 19))); 272 } 273 274 TEST_F(BasicFileAnalysisTest, DefiniteNextInstructionTest) { 275 Analysis.parseSectionContents( 276 { 277 0x90, // 0: nop 278 0xb0, 0x00, // 1: mov $0x0, %al 279 0x2f, // 3: (bad) 280 0x0f, 0x0b, // 4: ud2 281 0xff, 0x20, // 6: jmpq *(%rax) 282 0xeb, 0x00, // 8: jmp 10 [+0] 283 0xeb, 0x05, // 10: jmp 17 [+5] 284 0xe8, 0x00, 0x00, 0x00, 0x00, // 12: callq 17 [+0] 285 0xe8, 0x78, 0x56, 0x34, 0x12, // 17: callq 0x1234569f [+0x12345678] 286 0xe8, 0x04, 0x00, 0x00, 0x00, // 22: callq 31 [+4] 287 0xff, 0x10, // 27: callq *(rax) 288 0x75, 0x00, // 29: jne 31 [+0] 289 0x75, 0xe0, // 31: jne 1 [-32] 290 0xc3, // 33: retq 291 0xeb, 0xdd, // 34: jmp 1 [-35] 292 0xeb, 0xdd, // 36: jmp 3 [-35] 293 0xeb, 0xdc, // 38: jmp 4 [-36] 294 }, 295 0xDEADBEEF); 296 297 const auto *Current = Analysis.getInstruction(0xDEADBEEF); 298 const auto *Next = Analysis.getDefiniteNextInstruction(*Current); 299 EXPECT_NE(nullptr, Next); 300 EXPECT_EQ(0xDEADBEEF + 1, Next->VMAddress); 301 302 Current = Analysis.getInstruction(0xDEADBEEF + 1); 303 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 304 305 Current = Analysis.getInstruction(0xDEADBEEF + 3); 306 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 307 308 Current = Analysis.getInstruction(0xDEADBEEF + 4); 309 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 310 311 Current = Analysis.getInstruction(0xDEADBEEF + 6); 312 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 313 314 Current = Analysis.getInstruction(0xDEADBEEF + 8); 315 Next = Analysis.getDefiniteNextInstruction(*Current); 316 EXPECT_NE(nullptr, Next); 317 EXPECT_EQ(0xDEADBEEF + 10, Next->VMAddress); 318 319 Current = Analysis.getInstruction(0xDEADBEEF + 10); 320 Next = Analysis.getDefiniteNextInstruction(*Current); 321 EXPECT_NE(nullptr, Next); 322 EXPECT_EQ(0xDEADBEEF + 17, Next->VMAddress); 323 324 Current = Analysis.getInstruction(0xDEADBEEF + 12); 325 Next = Analysis.getDefiniteNextInstruction(*Current); 326 EXPECT_NE(nullptr, Next); 327 EXPECT_EQ(0xDEADBEEF + 17, Next->VMAddress); 328 329 Current = Analysis.getInstruction(0xDEADBEEF + 17); 330 // Note, definite next instruction address is out of range and should fail. 331 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 332 Next = Analysis.getDefiniteNextInstruction(*Current); 333 334 Current = Analysis.getInstruction(0xDEADBEEF + 22); 335 Next = Analysis.getDefiniteNextInstruction(*Current); 336 EXPECT_NE(nullptr, Next); 337 EXPECT_EQ(0xDEADBEEF + 31, Next->VMAddress); 338 339 Current = Analysis.getInstruction(0xDEADBEEF + 27); 340 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 341 Current = Analysis.getInstruction(0xDEADBEEF + 29); 342 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 343 Current = Analysis.getInstruction(0xDEADBEEF + 31); 344 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 345 Current = Analysis.getInstruction(0xDEADBEEF + 33); 346 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 347 348 Current = Analysis.getInstruction(0xDEADBEEF + 34); 349 Next = Analysis.getDefiniteNextInstruction(*Current); 350 EXPECT_NE(nullptr, Next); 351 EXPECT_EQ(0xDEADBEEF + 1, Next->VMAddress); 352 353 Current = Analysis.getInstruction(0xDEADBEEF + 36); 354 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current)); 355 356 Current = Analysis.getInstruction(0xDEADBEEF + 38); 357 Next = Analysis.getDefiniteNextInstruction(*Current); 358 EXPECT_NE(nullptr, Next); 359 EXPECT_EQ(0xDEADBEEF + 4, Next->VMAddress); 360 } 361 362 TEST_F(BasicFileAnalysisTest, ControlFlowXRefsTest) { 363 Analysis.parseSectionContents( 364 { 365 0x90, // 0: nop 366 0xb0, 0x00, // 1: mov $0x0, %al 367 0x2f, // 3: (bad) 368 0x0f, 0x0b, // 4: ud2 369 0xff, 0x20, // 6: jmpq *(%rax) 370 0xeb, 0x00, // 8: jmp 10 [+0] 371 0xeb, 0x05, // 10: jmp 17 [+5] 372 0xe8, 0x00, 0x00, 0x00, 0x00, // 12: callq 17 [+0] 373 0xe8, 0x78, 0x56, 0x34, 0x12, // 17: callq 0x1234569f [+0x12345678] 374 0xe8, 0x04, 0x00, 0x00, 0x00, // 22: callq 31 [+4] 375 0xff, 0x10, // 27: callq *(rax) 376 0x75, 0x00, // 29: jne 31 [+0] 377 0x75, 0xe0, // 31: jne 1 [-32] 378 0xc3, // 33: retq 379 0xeb, 0xdd, // 34: jmp 1 [-35] 380 0xeb, 0xdd, // 36: jmp 3 [-35] 381 0xeb, 0xdc, // 38: jmp 4 [-36] 382 }, 383 0xDEADBEEF); 384 const auto *InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF); 385 std::set<const Instr *> XRefs = 386 Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 387 EXPECT_TRUE(XRefs.empty()); 388 389 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 1); 390 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 391 EXPECT_THAT(XRefs, UnorderedElementsAre( 392 Field(&Instr::VMAddress, Eq(0xDEADBEEF)), 393 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 31)), 394 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 34)))); 395 396 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 3); 397 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 398 EXPECT_THAT(XRefs, UnorderedElementsAre( 399 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 1)), 400 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 36)))); 401 402 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 4); 403 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 404 EXPECT_THAT(XRefs, UnorderedElementsAre( 405 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 38)))); 406 407 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 6); 408 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 409 410 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 8); 411 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 412 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 413 414 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 10); 415 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 416 EXPECT_THAT(XRefs, UnorderedElementsAre( 417 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 8)))); 418 419 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 12); 420 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 421 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 422 423 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 17); 424 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 425 EXPECT_THAT(XRefs, UnorderedElementsAre( 426 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 10)), 427 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 12)))); 428 429 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 22); 430 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 431 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 432 433 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 27); 434 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 435 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 436 437 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 29); 438 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 439 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 440 441 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 31); 442 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 443 EXPECT_THAT(XRefs, UnorderedElementsAre( 444 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 22)), 445 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 29)))); 446 447 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 33); 448 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 449 EXPECT_THAT(XRefs, UnorderedElementsAre( 450 Field(&Instr::VMAddress, Eq(0xDEADBEEF + 31)))); 451 452 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 34); 453 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 454 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 455 456 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 36); 457 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 458 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 459 460 InstrMetaPtr = &Analysis.getInstructionOrDie(0xDEADBEEF + 38); 461 XRefs = Analysis.getDirectControlFlowXRefs(*InstrMetaPtr); 462 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty()); 463 } 464 465 } // anonymous namespace 466 } // end namespace cfi_verify 467 } // end namespace llvm 468 469 int main(int argc, char **argv) { 470 ::testing::InitGoogleTest(&argc, argv); 471 llvm::cl::ParseCommandLineOptions(argc, argv); 472 473 llvm::InitializeAllTargetInfos(); 474 llvm::InitializeAllTargetMCs(); 475 llvm::InitializeAllAsmParsers(); 476 llvm::InitializeAllDisassemblers(); 477 478 return RUN_ALL_TESTS(); 479 } 480