From 668e1d7984126e64dffbcbcac95508d239fd3187 Mon Sep 17 00:00:00 2001 From: Vlad Tsyrklevich Date: Tue, 10 Oct 2017 21:21:13 +0000 Subject: [PATCH] Revert "Classify llvm-cfi-verify." This reverts commit r315363. It has a simple build failure, but more importantly I want to confirm that unit tests run in check-all to make sure that they don't silently break in the future. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@315370 91177308-0d34-0410-b5e6-96231b3b80d8 --- tools/llvm-cfi-verify/CMakeLists.txt | 1 - tools/llvm-cfi-verify/FileAnalysis.cpp | 274 ------------------ tools/llvm-cfi-verify/FileAnalysis.h | 157 ---------- tools/llvm-cfi-verify/llvm-cfi-verify.cpp | 212 +++++++++++++- .../llvm-cfi-verify/unittests/CMakeLists.txt | 17 -- .../unittests/FileAnalysis.cpp | 216 -------------- unittests/CMakeLists.txt | 1 - 7 files changed, 196 insertions(+), 682 deletions(-) delete mode 100644 tools/llvm-cfi-verify/FileAnalysis.cpp delete mode 100644 tools/llvm-cfi-verify/FileAnalysis.h delete mode 100644 tools/llvm-cfi-verify/unittests/CMakeLists.txt delete mode 100644 tools/llvm-cfi-verify/unittests/FileAnalysis.cpp diff --git a/tools/llvm-cfi-verify/CMakeLists.txt b/tools/llvm-cfi-verify/CMakeLists.txt index ff7d7b92f4e..d6dce723aaf 100644 --- a/tools/llvm-cfi-verify/CMakeLists.txt +++ b/tools/llvm-cfi-verify/CMakeLists.txt @@ -13,5 +13,4 @@ set(LLVM_LINK_COMPONENTS add_llvm_tool(llvm-cfi-verify llvm-cfi-verify.cpp - FileAnalysis.cpp ) diff --git a/tools/llvm-cfi-verify/FileAnalysis.cpp b/tools/llvm-cfi-verify/FileAnalysis.cpp deleted file mode 100644 index cd38ae5d36a..00000000000 --- a/tools/llvm-cfi-verify/FileAnalysis.cpp +++ /dev/null @@ -1,274 +0,0 @@ -//===- FileAnalysis.cpp -----------------------------------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "FileAnalysis.h" - -#include "llvm/BinaryFormat/ELF.h" -#include "llvm/MC/MCAsmInfo.h" -#include "llvm/MC/MCContext.h" -#include "llvm/MC/MCDisassembler/MCDisassembler.h" -#include "llvm/MC/MCInst.h" -#include "llvm/MC/MCInstPrinter.h" -#include "llvm/MC/MCInstrAnalysis.h" -#include "llvm/MC/MCInstrDesc.h" -#include "llvm/MC/MCInstrInfo.h" -#include "llvm/MC/MCObjectFileInfo.h" -#include "llvm/MC/MCRegisterInfo.h" -#include "llvm/MC/MCSubtargetInfo.h" -#include "llvm/Object/Binary.h" -#include "llvm/Object/COFF.h" -#include "llvm/Object/ELFObjectFile.h" -#include "llvm/Object/ObjectFile.h" -#include "llvm/Support/Casting.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/Error.h" -#include "llvm/Support/FormatVariadic.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/TargetRegistry.h" -#include "llvm/Support/TargetSelect.h" -#include "llvm/Support/raw_ostream.h" - -#include - -using Instr = llvm::cfi_verify::FileAnalysis::Instr; - -namespace llvm { -namespace cfi_verify { - -Expected FileAnalysis::Create(StringRef Filename) { - // Open the filename provided. - Expected> BinaryOrErr = - object::createBinary(Filename); - if (!BinaryOrErr) - return BinaryOrErr.takeError(); - - // Construct the object and allow it to take ownership of the binary. - object::OwningBinary Binary = std::move(BinaryOrErr.get()); - FileAnalysis Analysis(std::move(Binary)); - - Analysis.Object = dyn_cast(Analysis.Binary.getBinary()); - if (!Analysis.Object) - return make_error(); - - Analysis.ObjectTriple = Analysis.Object->makeTriple(); - Analysis.Features = Analysis.Object->getFeatures(); - - // Init the rest of the object. - if (auto InitResponse = Analysis.initialiseDisassemblyMembers()) - return std::move(InitResponse); - - if (auto SectionParseResponse = Analysis.parseCodeSections()) - return std::move(SectionParseResponse); - - return std::move(Analysis); -} - -FileAnalysis::FileAnalysis(object::OwningBinary Binary) - : Binary(std::move(Binary)) {} - -FileAnalysis::FileAnalysis(const Triple &ObjectTriple, - const SubtargetFeatures &Features) - : ObjectTriple(ObjectTriple), Features(Features) {} - -const Instr * -FileAnalysis::getPrevInstructionSequential(const Instr &InstrMeta) const { - std::map::const_iterator KV = - Instructions.find(InstrMeta.VMAddress); - if (KV == Instructions.end() || KV == Instructions.begin()) - return nullptr; - - if (!(--KV)->second.Valid) - return nullptr; - - return &KV->second; -} - -const Instr * -FileAnalysis::getNextInstructionSequential(const Instr &InstrMeta) const { - std::map::const_iterator KV = - Instructions.find(InstrMeta.VMAddress); - if (KV == Instructions.end() || ++KV == Instructions.end()) - return nullptr; - - if (!KV->second.Valid) - return nullptr; - - return &KV->second; -} - -bool FileAnalysis::usesRegisterOperand(const Instr& InstrMeta) const { - for (const auto &Operand : InstrMeta.Instruction) { - if (Operand.isReg()) - return true; - } - return false; -} - -const Instr *FileAnalysis::getInstruction(uint64_t Address) const { - const auto &InstrKV = Instructions.find(Address); - if (InstrKV == Instructions.end()) - return nullptr; - - return &InstrKV->second; -} - -const Instr &FileAnalysis::getInstructionOrDie(uint64_t Address) const { - const auto &InstrKV = Instructions.find(Address); - assert(InstrKV != Instructions.end() && "Address doesn't exist."); - return InstrKV->second; -} - -const std::set &FileAnalysis::getIndirectInstructions() const { - return IndirectInstructions; -} - -const MCRegisterInfo *FileAnalysis::getRegisterInfo() const { - return RegisterInfo.get(); -} - -const MCInstrInfo *FileAnalysis::getMCInstrInfo() const { return MII.get(); } - -const MCInstrAnalysis *FileAnalysis::getMCInstrAnalysis() const { - return MIA.get(); -} - -Error FileAnalysis::initialiseDisassemblyMembers() { - std::string TripleName = ObjectTriple.getTriple(); - ArchName = ""; - MCPU = ""; - std::string ErrorString; - - ObjectTarget = - TargetRegistry::lookupTarget(ArchName, ObjectTriple, ErrorString); - if (!ObjectTarget) - return make_error(Twine("Couldn't find target \"") + - ObjectTriple.getTriple() + - "\", failed with error: " + ErrorString, - inconvertibleErrorCode()); - - RegisterInfo.reset(ObjectTarget->createMCRegInfo(TripleName)); - if (!RegisterInfo) - return make_error("Failed to initialise RegisterInfo.", - inconvertibleErrorCode()); - - AsmInfo.reset(ObjectTarget->createMCAsmInfo(*RegisterInfo, TripleName)); - if (!AsmInfo) - return make_error("Failed to initialise AsmInfo.", - inconvertibleErrorCode()); - - SubtargetInfo.reset(ObjectTarget->createMCSubtargetInfo( - TripleName, MCPU, Features.getString())); - if (!SubtargetInfo) - return make_error("Failed to initialise SubtargetInfo.", - inconvertibleErrorCode()); - - MII.reset(ObjectTarget->createMCInstrInfo()); - if (!MII) - return make_error("Failed to initialise MII.", - inconvertibleErrorCode()); - - Context.reset(new MCContext(AsmInfo.get(), RegisterInfo.get(), &MOFI)); - - Disassembler.reset( - ObjectTarget->createMCDisassembler(*SubtargetInfo, *Context)); - - if (!Disassembler) - return make_error("No disassembler available for target", - inconvertibleErrorCode()); - - MIA.reset(ObjectTarget->createMCInstrAnalysis(MII.get())); - - Printer.reset(ObjectTarget->createMCInstPrinter( - ObjectTriple, AsmInfo->getAssemblerDialect(), *AsmInfo, *MII, - *RegisterInfo)); - - return Error::success(); -} - -Error FileAnalysis::parseCodeSections() { - for (const object::SectionRef &Section : Object->sections()) { - // Ensure only executable sections get analysed. - if (!(object::ELFSectionRef(Section).getFlags() & ELF::SHF_EXECINSTR)) - continue; - - StringRef SectionContents; - if (Section.getContents(SectionContents)) - return make_error("Failed to retrieve section contents", - inconvertibleErrorCode()); - - ArrayRef SectionBytes((const uint8_t *)SectionContents.data(), - Section.getSize()); - parseSectionContents(SectionBytes, Section.getAddress()); - } - return Error::success(); -} - -void FileAnalysis::parseSectionContents(ArrayRef SectionBytes, - uint64_t SectionAddress) { - MCInst Instruction; - Instr InstrMeta; - uint64_t InstructionSize; - - for (uint64_t Byte = 0; Byte < SectionBytes.size();) { - bool ValidInstruction = - Disassembler->getInstruction(Instruction, InstructionSize, - SectionBytes.drop_front(Byte), 0, nulls(), - outs()) == MCDisassembler::Success; - - Byte += InstructionSize; - - uint64_t VMAddress = SectionAddress + Byte - InstructionSize; - InstrMeta.Instruction = Instruction; - InstrMeta.VMAddress = VMAddress; - InstrMeta.InstructionSize = InstructionSize; - InstrMeta.Valid = ValidInstruction; - addInstruction(InstrMeta); - - if (!ValidInstruction) - continue; - - // Skip additional parsing for instructions that do not affect the control - // flow. - const auto &InstrDesc = MII->get(Instruction.getOpcode()); - if (!InstrDesc.mayAffectControlFlow(Instruction, *RegisterInfo)) - continue; - - uint64_t Target; - if (MIA->evaluateBranch(Instruction, VMAddress, InstructionSize, Target)) { - // If the target can be evaluated, it's not indirect. - StaticBranchTargetings[Target].push_back(VMAddress); - continue; - } - - if (!usesRegisterOperand(InstrMeta)) - continue; - - IndirectInstructions.insert(VMAddress); - } -} - -void FileAnalysis::addInstruction(const Instr &Instruction) { - const auto &KV = - Instructions.insert(std::make_pair(Instruction.VMAddress, Instruction)); - assert( - KV.second && - "Failed to add instruction, instruction at this address already exists."); -} - -char UnsupportedDisassembly::ID; -void UnsupportedDisassembly::log(raw_ostream &OS) const { - OS << "Dissassembling of non-objects not currently supported.\n"; -} - -std::error_code UnsupportedDisassembly::convertToErrorCode() const { - return std::error_code(); -} - -} // namespace cfi_verify -} // namespace llvm diff --git a/tools/llvm-cfi-verify/FileAnalysis.h b/tools/llvm-cfi-verify/FileAnalysis.h deleted file mode 100644 index f33586145b0..00000000000 --- a/tools/llvm-cfi-verify/FileAnalysis.h +++ /dev/null @@ -1,157 +0,0 @@ -//===- FileAnalysis.h -------------------------------------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_CFI_VERIFY_FILE_ANALYSIS_H -#define LLVM_CFI_VERIFY_FILE_ANALYSIS_H - -#include "llvm/BinaryFormat/ELF.h" -#include "llvm/MC/MCAsmInfo.h" -#include "llvm/MC/MCContext.h" -#include "llvm/MC/MCDisassembler/MCDisassembler.h" -#include "llvm/MC/MCInst.h" -#include "llvm/MC/MCInstPrinter.h" -#include "llvm/MC/MCInstrAnalysis.h" -#include "llvm/MC/MCInstrDesc.h" -#include "llvm/MC/MCInstrInfo.h" -#include "llvm/MC/MCObjectFileInfo.h" -#include "llvm/MC/MCRegisterInfo.h" -#include "llvm/MC/MCSubtargetInfo.h" -#include "llvm/Object/Binary.h" -#include "llvm/Object/COFF.h" -#include "llvm/Object/ELFObjectFile.h" -#include "llvm/Object/ObjectFile.h" -#include "llvm/Support/Casting.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/Error.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/TargetRegistry.h" -#include "llvm/Support/TargetSelect.h" -#include "llvm/Support/raw_ostream.h" - -#include -#include -#include -#include - -namespace llvm { -namespace cfi_verify { - -// Disassembler and analysis tool for machine code files. Keeps track of non- -// sequential control flows, including indirect control flow instructions. -class FileAnalysis { -public: - // A metadata struct for an instruction. - struct Instr { - uint64_t VMAddress; // Virtual memory address of this instruction. - MCInst Instruction; // Instruction. - uint64_t InstructionSize; // Size of this instruction. - bool Valid; // Is this a valid instruction? If false, Instr::Instruction is - // undefined. - }; - - // Construct a FileAnalysis from a file path. - static Expected Create(StringRef Filename); - - // Construct and take ownership of the supplied object. Do not use this - // constructor, prefer to use FileAnalysis::Create instead. - FileAnalysis(object::OwningBinary Binary); - FileAnalysis() = delete; - FileAnalysis(const FileAnalysis &) = delete; - FileAnalysis(FileAnalysis &&Other) = default; - - // Returns the instruction at the provided address. Returns nullptr if there - // is no instruction at the provided address. - const Instr *getInstruction(uint64_t Address) const; - - // Returns the instruction at the provided adress, dying if the instruction is - // not found. - const Instr &getInstructionOrDie(uint64_t Address) const; - - // Returns a pointer to the previous/next instruction in sequence, - // respectively. Returns nullptr if the next/prev instruction doesn't exist, - // or if the provided instruction doesn't exist. - const Instr *getPrevInstructionSequential(const Instr &InstrMeta) const; - const Instr *getNextInstructionSequential(const Instr &InstrMeta) const; - - // Returns whether this instruction uses a register operand. - bool usesRegisterOperand(const Instr &InstrMeta) const; - - // Returns the list of indirect instructions. - const std::set &getIndirectInstructions() const; - - const MCRegisterInfo *getRegisterInfo() const; - const MCInstrInfo *getMCInstrInfo() const; - const MCInstrAnalysis *getMCInstrAnalysis() const; - -protected: - // Construct a blank object with the provided triple and features. Used in - // testing, where a sub class will dependency inject protected methods to - // allow analysis of raw binary, without requiring a fully valid ELF file. - FileAnalysis(const Triple &ObjectTriple, const SubtargetFeatures &Features); - - // Add an instruction to this object. - void addInstruction(const Instr &Instruction); - - // Disassemble and parse the provided bytes into this object. Instruction - // address calculation is done relative to the provided SectionAddress. - void parseSectionContents(ArrayRef SectionBytes, - uint64_t SectionAddress); - - // Constructs and initialises members required for disassembly. - Error initialiseDisassemblyMembers(); - - // Parses code sections from the internal object file. Saves them into the - // internal members. Should only be called once by Create(). - Error parseCodeSections(); - -private: - // Members that describe the input file. - object::OwningBinary Binary; - const object::ObjectFile *Object = nullptr; - Triple ObjectTriple; - std::string ArchName; - std::string MCPU; - const Target *ObjectTarget = nullptr; - SubtargetFeatures Features; - - // Members required for disassembly. - std::unique_ptr RegisterInfo; - std::unique_ptr AsmInfo; - std::unique_ptr SubtargetInfo; - std::unique_ptr MII; - MCObjectFileInfo MOFI; - std::unique_ptr Context; - std::unique_ptr Disassembler; - std::unique_ptr MIA; - std::unique_ptr Printer; - - // A mapping between the virtual memory address to the instruction metadata - // struct. - std::map Instructions; - - // Contains a mapping between a specific address, and a list of instructions - // that use this address as a branch target (including call instructions). - std::unordered_map> StaticBranchTargetings; - - // A list of addresses of indirect control flow instructions. - std::set IndirectInstructions; -}; - -class UnsupportedDisassembly : public ErrorInfo { -public: - static char ID; - - void log(raw_ostream &OS) const override; - std::error_code convertToErrorCode() const override; -}; - -} // namespace cfi_verify -} // namespace llvm - -#endif // LLVM_CFI_VERIFY_FILE_ANALYSIS_H diff --git a/tools/llvm-cfi-verify/llvm-cfi-verify.cpp b/tools/llvm-cfi-verify/llvm-cfi-verify.cpp index 2aaa702abf8..63dc6f128e1 100644 --- a/tools/llvm-cfi-verify/llvm-cfi-verify.cpp +++ b/tools/llvm-cfi-verify/llvm-cfi-verify.cpp @@ -17,31 +17,64 @@ // //===----------------------------------------------------------------------===// -#include "FileAnalysis.h" - -#include "llvm/BinaryFormat/ELF.h" +#include "llvm/MC/MCAsmInfo.h" +#include "llvm/MC/MCContext.h" +#include "llvm/MC/MCDisassembler/MCDisassembler.h" +#include "llvm/MC/MCInst.h" +#include "llvm/MC/MCInstPrinter.h" +#include "llvm/MC/MCInstrAnalysis.h" +#include "llvm/MC/MCInstrDesc.h" +#include "llvm/MC/MCInstrInfo.h" +#include "llvm/MC/MCObjectFileInfo.h" +#include "llvm/MC/MCRegisterInfo.h" +#include "llvm/MC/MCSubtargetInfo.h" +#include "llvm/Object/Binary.h" +#include "llvm/Object/COFF.h" +#include "llvm/Object/ObjectFile.h" +#include "llvm/Support/Casting.h" #include "llvm/Support/CommandLine.h" -#include "llvm/Support/Error.h" +#include "llvm/Support/MemoryBuffer.h" +#include "llvm/Support/TargetRegistry.h" +#include "llvm/Support/TargetSelect.h" +#include "llvm/Support/raw_ostream.h" +#include #include using namespace llvm; using namespace llvm::object; -using namespace llvm::cfi_verify; +cl::opt ArgDumpSymbols("sym", cl::desc("Dump the symbol table.")); cl::opt InputFilename(cl::Positional, cl::desc(""), cl::Required); -ExitOnError ExitOnErr; +static void printSymbols(const ObjectFile *Object) { + for (const SymbolRef &Symbol : Object->symbols()) { + outs() << "Symbol [" << format_hex_no_prefix(Symbol.getValue(), 2) + << "] = "; + + auto SymbolName = Symbol.getName(); + if (SymbolName) + outs() << *SymbolName; + else + outs() << "UNKNOWN"; + + if (Symbol.getFlags() & SymbolRef::SF_Hidden) + outs() << " .hidden"; + + outs() << " (Section = "; + + auto SymbolSection = Symbol.getSection(); + if (SymbolSection) { + StringRef SymbolSectionName; + if ((*SymbolSection)->getName(SymbolSectionName)) + outs() << "UNKNOWN)"; + else + outs() << SymbolSectionName << ")"; + } else { + outs() << "N/A)"; + } -void printIndirectCFInstructions(const FileAnalysis &Verifier) { - for (uint64_t Address : Verifier.getIndirectInstructions()) { - const auto &InstrMeta = Verifier.getInstructionOrDie(Address); - outs() << format_hex(Address, 2) << " |" - << Verifier.getMCInstrInfo()->getName( - InstrMeta.Instruction.getOpcode()) - << " "; - InstrMeta.Instruction.print(outs()); outs() << "\n"; } } @@ -54,8 +87,155 @@ int main(int argc, char **argv) { InitializeAllAsmParsers(); InitializeAllDisassemblers(); - FileAnalysis Verifier = ExitOnErr(FileAnalysis::Create(InputFilename)); - printIndirectCFInstructions(Verifier); + Expected> BinaryOrErr = createBinary(InputFilename); + if (!BinaryOrErr) { + errs() << "Failed to open file.\n"; + return EXIT_FAILURE; + } + + Binary &Binary = *BinaryOrErr.get().getBinary(); + ObjectFile *Object = dyn_cast(&Binary); + if (!Object) { + errs() << "Disassembling of non-objects not currently supported.\n"; + return EXIT_FAILURE; + } + + Triple TheTriple = Object->makeTriple(); + std::string TripleName = TheTriple.getTriple(); + std::string ArchName = ""; + std::string ErrorString; + + const Target *TheTarget = + TargetRegistry::lookupTarget(ArchName, TheTriple, ErrorString); + + if (!TheTarget) { + errs() << "Couldn't find target \"" << TheTriple.getTriple() + << "\", failed with error: " << ErrorString << ".\n"; + return EXIT_FAILURE; + } + + SubtargetFeatures Features = Object->getFeatures(); + + std::unique_ptr RegisterInfo( + TheTarget->createMCRegInfo(TripleName)); + if (!RegisterInfo) { + errs() << "Failed to initialise RegisterInfo.\n"; + return EXIT_FAILURE; + } + + std::unique_ptr AsmInfo( + TheTarget->createMCAsmInfo(*RegisterInfo, TripleName)); + if (!AsmInfo) { + errs() << "Failed to initialise AsmInfo.\n"; + return EXIT_FAILURE; + } + + std::string MCPU = ""; + std::unique_ptr SubtargetInfo( + TheTarget->createMCSubtargetInfo(TripleName, MCPU, Features.getString())); + if (!SubtargetInfo) { + errs() << "Failed to initialise SubtargetInfo.\n"; + return EXIT_FAILURE; + } + + std::unique_ptr MII(TheTarget->createMCInstrInfo()); + if (!MII) { + errs() << "Failed to initialise MII.\n"; + return EXIT_FAILURE; + } + + MCObjectFileInfo MOFI; + MCContext Context(AsmInfo.get(), RegisterInfo.get(), &MOFI); + + std::unique_ptr Disassembler( + TheTarget->createMCDisassembler(*SubtargetInfo, Context)); + + if (!Disassembler) { + errs() << "No disassembler available for target."; + return EXIT_FAILURE; + } + + std::unique_ptr MIA( + TheTarget->createMCInstrAnalysis(MII.get())); + + std::unique_ptr Printer( + TheTarget->createMCInstPrinter(TheTriple, AsmInfo->getAssemblerDialect(), + *AsmInfo, *MII, *RegisterInfo)); + + if (ArgDumpSymbols) + printSymbols(Object); + + for (const SectionRef &Section : Object->sections()) { + outs() << "Section [" << format_hex_no_prefix(Section.getAddress(), 2) + << "] = "; + StringRef SectionName; + + if (Section.getName(SectionName)) + outs() << "UNKNOWN.\n"; + else + outs() << SectionName << "\n"; + + StringRef SectionContents; + if (Section.getContents(SectionContents)) { + errs() << "Failed to retrieve section contents.\n"; + return EXIT_FAILURE; + } + + MCInst Instruction; + uint64_t InstructionSize; + + ArrayRef SectionBytes((const uint8_t *)SectionContents.data(), + Section.getSize()); + + for (uint64_t Byte = 0; Byte < Section.getSize();) { + bool BadInstruction = false; + + // Disassemble the instruction. + if (Disassembler->getInstruction( + Instruction, InstructionSize, SectionBytes.drop_front(Byte), 0, + nulls(), outs()) != MCDisassembler::Success) { + BadInstruction = true; + } + + Byte += InstructionSize; + + if (BadInstruction) + continue; + + // Skip instructions that do not affect the control flow. + const auto &InstrDesc = MII->get(Instruction.getOpcode()); + if (!InstrDesc.mayAffectControlFlow(Instruction, *RegisterInfo)) + continue; + + // Skip instructions that do not operate on register operands. + bool UsesRegisterOperand = false; + for (const auto &Operand : Instruction) { + if (Operand.isReg()) + UsesRegisterOperand = true; + } + + if (!UsesRegisterOperand) + continue; + + // Print the instruction address. + outs() << " " + << format_hex(Section.getAddress() + Byte - InstructionSize, 2) + << ": "; + + // Print the instruction bytes. + for (uint64_t i = 0; i < InstructionSize; ++i) { + outs() << format_hex_no_prefix(SectionBytes[Byte - InstructionSize + i], + 2) + << " "; + } + + // Print the instruction. + outs() << " | " << MII->getName(Instruction.getOpcode()) << " "; + Instruction.dump_pretty(outs(), Printer.get()); + + outs() << "\n"; + } + } return EXIT_SUCCESS; } diff --git a/tools/llvm-cfi-verify/unittests/CMakeLists.txt b/tools/llvm-cfi-verify/unittests/CMakeLists.txt deleted file mode 100644 index 32a7d12c0bd..00000000000 --- a/tools/llvm-cfi-verify/unittests/CMakeLists.txt +++ /dev/null @@ -1,17 +0,0 @@ -set(LLVM_LINK_COMPONENTS - AllTargetsAsmPrinters - AllTargetsAsmParsers - AllTargetsDescs - AllTargetsDisassemblers - AllTargetsInfos - MC - Object - MCParser - Object - Support - ) - - - -add_llvm_unittest(CFIVerifyTests - FileAnalysis.cpp ../FileAnalysis.cpp) diff --git a/tools/llvm-cfi-verify/unittests/FileAnalysis.cpp b/tools/llvm-cfi-verify/unittests/FileAnalysis.cpp deleted file mode 100644 index c2a94012adf..00000000000 --- a/tools/llvm-cfi-verify/unittests/FileAnalysis.cpp +++ /dev/null @@ -1,216 +0,0 @@ -//===- llvm/tools/llvm-cfi-verify/unittests/FileAnalysis.cpp --------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "../FileAnalysis.h" -#include "gmock/gmock.h" -#include "gtest/gtest.h" - -#include "llvm/BinaryFormat/ELF.h" -#include "llvm/MC/MCAsmInfo.h" -#include "llvm/MC/MCContext.h" -#include "llvm/MC/MCDisassembler/MCDisassembler.h" -#include "llvm/MC/MCInst.h" -#include "llvm/MC/MCInstPrinter.h" -#include "llvm/MC/MCInstrAnalysis.h" -#include "llvm/MC/MCInstrDesc.h" -#include "llvm/MC/MCInstrInfo.h" -#include "llvm/MC/MCObjectFileInfo.h" -#include "llvm/MC/MCRegisterInfo.h" -#include "llvm/MC/MCSubtargetInfo.h" -#include "llvm/Object/Binary.h" -#include "llvm/Object/COFF.h" -#include "llvm/Object/ELFObjectFile.h" -#include "llvm/Object/ObjectFile.h" -#include "llvm/Support/Casting.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/Error.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/TargetRegistry.h" -#include "llvm/Support/TargetSelect.h" -#include "llvm/Support/raw_ostream.h" - -#include - -using Instr = ::llvm::cfi_verify::FileAnalysis::Instr; -using ::testing::Eq; - -namespace llvm { -namespace cfi_verify { -namespace { -class ELFx86TestFileAnalysis : public FileAnalysis { -public: - ELFx86TestFileAnalysis() - : FileAnalysis(Triple("x86_64--"), SubtargetFeatures()) {} - - // Expose this method publicly for testing. - void parseSectionContents(ArrayRef SectionBytes, - uint64_t SectionAddress) { - FileAnalysis::parseSectionContents(SectionBytes, SectionAddress); - } - - Error initialiseDisassemblyMembers() { - return FileAnalysis::initialiseDisassemblyMembers(); - } -}; - -class BasicFileAnalysisTest : public ::testing::Test { -protected: - virtual void SetUp() { - if (Verifier.initialiseDisassemblyMembers()) { - FAIL() << "Failed to initialise FileAnalysis."; - } - } - - ELFx86TestFileAnalysis Verifier; -}; - -TEST_F(BasicFileAnalysisTest, BasicDisassemblyTraversalTest) { - Verifier.parseSectionContents( - { - 0x90, // 0: nop - 0xb0, 0x00, // 1: mov $0x0, %al - 0x48, 0x89, 0xe5, // 3: mov %rsp, %rbp - 0x48, 0x83, 0xec, 0x18, // 6: sub $0x18, %rsp - 0x48, 0xbe, 0xc4, 0x07, 0x40, - 0x00, 0x00, 0x00, 0x00, 0x00, // 10: movabs $0x4007c4, %rsi - 0x2f, // 20: (bad) - 0x41, 0x0e, // 21: rex.B (bad) - 0x62, 0x72, 0x65, 0x61, 0x6b, // 23: (bad) {%k1} - }, - 0xDEADBEEF); - - EXPECT_EQ(nullptr, Verifier.getInstruction(0x0)); - EXPECT_EQ(nullptr, Verifier.getInstruction(0x1000)); - - // 0xDEADBEEF: nop - const auto *InstrMeta = Verifier.getInstruction(0xDEADBEEF); - EXPECT_NE(nullptr, InstrMeta); - EXPECT_EQ(0xDEADBEEF, InstrMeta->VMAddress); - EXPECT_EQ(1u, InstrMeta->InstructionSize); - EXPECT_TRUE(InstrMeta->Valid); - - const auto *NextInstrMeta = Verifier.getNextInstructionSequential(*InstrMeta); - EXPECT_EQ(nullptr, Verifier.getPrevInstructionSequential(*InstrMeta)); - const auto *PrevInstrMeta = InstrMeta; - - // 0xDEADBEEF + 1: mov $0x0, %al - InstrMeta = Verifier.getInstruction(0xDEADBEEF + 1); - EXPECT_NE(nullptr, InstrMeta); - EXPECT_EQ(NextInstrMeta, InstrMeta); - EXPECT_EQ(0xDEADBEEF + 1, InstrMeta->VMAddress); - EXPECT_EQ(2u, InstrMeta->InstructionSize); - EXPECT_TRUE(InstrMeta->Valid); - - NextInstrMeta = Verifier.getNextInstructionSequential(*InstrMeta); - EXPECT_EQ(PrevInstrMeta, Verifier.getPrevInstructionSequential(*InstrMeta)); - PrevInstrMeta = InstrMeta; - - // 0xDEADBEEF + 3: mov %rsp, %rbp - InstrMeta = Verifier.getInstruction(0xDEADBEEF + 3); - EXPECT_NE(nullptr, InstrMeta); - EXPECT_EQ(NextInstrMeta, InstrMeta); - EXPECT_EQ(0xDEADBEEF + 3, InstrMeta->VMAddress); - EXPECT_EQ(3u, InstrMeta->InstructionSize); - EXPECT_TRUE(InstrMeta->Valid); - - NextInstrMeta = Verifier.getNextInstructionSequential(*InstrMeta); - EXPECT_EQ(PrevInstrMeta, Verifier.getPrevInstructionSequential(*InstrMeta)); - PrevInstrMeta = InstrMeta; - - // 0xDEADBEEF + 6: sub $0x18, %rsp - InstrMeta = Verifier.getInstruction(0xDEADBEEF + 6); - EXPECT_NE(nullptr, InstrMeta); - EXPECT_EQ(NextInstrMeta, InstrMeta); - EXPECT_EQ(0xDEADBEEF + 6, InstrMeta->VMAddress); - EXPECT_EQ(4u, InstrMeta->InstructionSize); - EXPECT_TRUE(InstrMeta->Valid); - - NextInstrMeta = Verifier.getNextInstructionSequential(*InstrMeta); - EXPECT_EQ(PrevInstrMeta, Verifier.getPrevInstructionSequential(*InstrMeta)); - PrevInstrMeta = InstrMeta; - - // 0xDEADBEEF + 10: movabs $0x4007c4, %rsi - InstrMeta = Verifier.getInstruction(0xDEADBEEF + 10); - EXPECT_NE(nullptr, InstrMeta); - EXPECT_EQ(NextInstrMeta, InstrMeta); - EXPECT_EQ(0xDEADBEEF + 10, InstrMeta->VMAddress); - EXPECT_EQ(10u, InstrMeta->InstructionSize); - EXPECT_TRUE(InstrMeta->Valid); - - EXPECT_EQ(nullptr, Verifier.getNextInstructionSequential(*InstrMeta)); - EXPECT_EQ(PrevInstrMeta, Verifier.getPrevInstructionSequential(*InstrMeta)); - PrevInstrMeta = InstrMeta; - - // 0xDEADBEEF + 20: (bad) - InstrMeta = Verifier.getInstruction(0xDEADBEEF + 20); - EXPECT_NE(nullptr, InstrMeta); - EXPECT_EQ(0xDEADBEEF + 20, InstrMeta->VMAddress); - EXPECT_EQ(1u, InstrMeta->InstructionSize); - EXPECT_FALSE(InstrMeta->Valid); - - EXPECT_EQ(nullptr, Verifier.getNextInstructionSequential(*InstrMeta)); - EXPECT_EQ(PrevInstrMeta, Verifier.getPrevInstructionSequential(*InstrMeta)); - - // 0xDEADBEEF + 21: rex.B (bad) - InstrMeta = Verifier.getInstruction(0xDEADBEEF + 21); - EXPECT_NE(nullptr, InstrMeta); - EXPECT_EQ(0xDEADBEEF + 21, InstrMeta->VMAddress); - EXPECT_EQ(2u, InstrMeta->InstructionSize); - EXPECT_FALSE(InstrMeta->Valid); - - EXPECT_EQ(nullptr, Verifier.getNextInstructionSequential(*InstrMeta)); - EXPECT_EQ(nullptr, Verifier.getPrevInstructionSequential(*InstrMeta)); - - // 0xDEADBEEF + 6: (bad) {%k1} - InstrMeta = Verifier.getInstruction(0xDEADBEEF + 23); - EXPECT_NE(nullptr, InstrMeta); - EXPECT_EQ(0xDEADBEEF + 23, InstrMeta->VMAddress); - EXPECT_EQ(5u, InstrMeta->InstructionSize); - EXPECT_FALSE(InstrMeta->Valid); - - EXPECT_EQ(nullptr, Verifier.getNextInstructionSequential(*InstrMeta)); - EXPECT_EQ(nullptr, Verifier.getPrevInstructionSequential(*InstrMeta)); -} - -TEST_F(BasicFileAnalysisTest, PrevAndNextFromBadInst) { - Verifier.parseSectionContents( - { - 0x90, // 0: nop - 0x2f, // 1: (bad) - 0x90 // 2: nop - }, - 0xDEADBEEF); - const auto &BadInstrMeta = Verifier.getInstructionOrDie(0xDEADBEEF + 1); - const auto *GoodInstrMeta = - Verifier.getPrevInstructionSequential(BadInstrMeta); - EXPECT_NE(nullptr, GoodInstrMeta); - EXPECT_EQ(0xDEADBEEF, GoodInstrMeta->VMAddress); - EXPECT_EQ(1u, GoodInstrMeta->InstructionSize); - - GoodInstrMeta = Verifier.getNextInstructionSequential(BadInstrMeta); - EXPECT_NE(nullptr, GoodInstrMeta); - EXPECT_EQ(0xDEADBEEF + 2, GoodInstrMeta->VMAddress); - EXPECT_EQ(1u, GoodInstrMeta->InstructionSize); -} - -} // anonymous namespace -} // end namespace cfi_verify -} // end namespace llvm - -int main(int argc, char **argv) { - ::testing::InitGoogleTest(&argc, argv); - llvm::cl::ParseCommandLineOptions(argc, argv); - - llvm::InitializeAllTargetInfos(); - llvm::InitializeAllTargetMCs(); - llvm::InitializeAllAsmParsers(); - llvm::InitializeAllDisassemblers(); - - return RUN_ALL_TESTS(); -} diff --git a/unittests/CMakeLists.txt b/unittests/CMakeLists.txt index 26013e752e0..af4a306f1cf 100644 --- a/unittests/CMakeLists.txt +++ b/unittests/CMakeLists.txt @@ -27,4 +27,3 @@ add_subdirectory(Support) add_subdirectory(Target) add_subdirectory(Transforms) add_subdirectory(XRay) -add_subdirectory(../tools/llvm-cfi-verify/unittests ../tools/llvm-cfi-verify/unittests) -- 2.40.0