Index: include/llvm/CodeGen/FaultMaps.h =================================================================== --- include/llvm/CodeGen/FaultMaps.h +++ include/llvm/CodeGen/FaultMaps.h @@ -12,6 +12,8 @@ #include "llvm/ADT/DenseMap.h" #include "llvm/MC/MCSymbol.h" +#include "llvm/Support/Endian.h" +#include "llvm/Support/Format.h" #include #include @@ -68,6 +70,162 @@ void emitFunctionInfo(const MCSymbol *FnLabel, const FunctionFaultInfos &FFI); }; + +/// A parser for the __llvm_faultmaps section generated by the FaultMaps class +/// above. This parser is version locked with with the __llvm_faultmaps section +/// generated by the version of that includes it. No guarantees are made with +/// respect to forward or backward compatibility. +template class FaultMapParser { + static const size_t FaultMapVersionOffset = 0; + static const size_t Reserved0Offset = FaultMapVersionOffset + sizeof(uint8_t); + static const size_t Reserved1Offset = Reserved0Offset + sizeof(uint8_t); + static const size_t NumFunctionsOffset = Reserved1Offset + sizeof(uint16_t); + static const size_t FunctionInfosOffset = + NumFunctionsOffset + sizeof(uint32_t); + + const uint8_t *P; + const uint8_t *E; + + template static T read(const uint8_t *P, const uint8_t *E) { + assert(P + sizeof(T) <= E && "out of bounds read!"); + return support::endian::read(P); + } + +public: + class FunctionFaultInfoAccessor; + + class FunctionInfoAccessor { + static const size_t FunctionAddrOffset = 0; + static const size_t NumFaultingPCsOffset = + FunctionAddrOffset + sizeof(uint64_t); + static const size_t ReservedOffset = + NumFaultingPCsOffset + sizeof(uint32_t); + static const size_t FunctionFaultInfosOffset = + ReservedOffset + sizeof(uint32_t); + static const size_t FunctionFaultInfoSize = sizeof(uint32_t) * 3; + + const uint8_t *P; + const uint8_t *E; + + public: + FunctionInfoAccessor() : P(nullptr), E(nullptr) {} + + explicit FunctionInfoAccessor(const uint8_t *P, const uint8_t *E) + : P(P), E(E) {} + + uint64_t getFunctionAddr() const { + return read(P + FunctionAddrOffset, E); + } + + uint32_t getNumFaultingPCs() const { + return read(P + NumFaultingPCsOffset, E); + } + + FunctionFaultInfoAccessor getFunctionFaultInfoAt(uint32_t idx) const { + assert(idx < getNumFaultingPCs() && "index out of bounds!"); + const uint8_t *Begin = + P + FunctionFaultInfosOffset + FunctionFaultInfoSize * idx; + return FunctionFaultInfoAccessor(Begin, E); + } + + FunctionInfoAccessor getNextFunctionInfo() const { + size_t MySize = sizeof(uint64_t) + // FunctionAddress + sizeof(uint32_t) + // NumFaultingPCs + sizeof(uint32_t) + // Reserved + getNumFaultingPCs() * FunctionFaultInfoSize; + + const uint8_t *Begin = P + MySize; + assert(Begin < E && "out of bounds!"); + return FunctionInfoAccessor(Begin, E); + } + }; + + class FunctionFaultInfoAccessor { + static const size_t FaultKindOffset = 0; + static const size_t FaultingPCOffsetOffset = + FaultKindOffset + sizeof(uint32_t); + static const size_t HandlerPCOffsetOffset = + FaultingPCOffsetOffset + sizeof(uint32_t); + + const uint8_t *P; + const uint8_t *E; + + public: + explicit FunctionFaultInfoAccessor(const uint8_t *P, const uint8_t *E) + : P(P), E(E) {} + + uint32_t getFaultKind() const { + return read(P + FaultKindOffset, E); + } + + uint32_t getFaultingPCOffset() const { + return read(P + FaultingPCOffsetOffset, E); + } + + uint32_t getHandlerPCOffset() const { + return read(P + HandlerPCOffsetOffset, E); + } + }; + + explicit FaultMapParser(const uint8_t *Begin, const uint8_t *End) + : P(Begin), E(End) {} + + uint8_t getFaultMapVersion() const { + uint8_t Version = read(P + FaultMapVersionOffset, E); + assert(Version == 1 && "only version 1 supported!"); + return Version; + } + + uint32_t getNumFunctions() const { + return read(P + NumFunctionsOffset, E); + } + + FunctionInfoAccessor getFirstFunctionInfo() const { + const uint8_t *Begin = P + FunctionInfosOffset; + return FunctionInfoAccessor(Begin, E); + } +}; + +template +raw_ostream &operator<<( + raw_ostream &OS, + const typename FaultMapParser::FunctionFaultInfoAccessor &FFI) { + OS << "Fault kind: " + << FaultMaps::faultTypeToString((FaultMaps::FaultKind)FFI.getFaultKind()) + << ", faulting PC offset: " << FFI.getFaultingPCOffset() + << ", handling PC offset: " << FFI.getHandlerPCOffset(); + return OS; +} + +template +raw_ostream &operator<<( + raw_ostream &OS, + const typename FaultMapParser::FunctionInfoAccessor &FI) { + OS << "FunctionAddress: " << format_hex(FI.getFunctionAddr(), 8) + << ", NumFaultingPCs: " << FI.getNumFaultingPCs() << "\n"; + for (unsigned i = 0, e = FI.getNumFaultingPCs(); i != e; ++i) + operator<<(OS, FI.getFunctionFaultInfoAt(i)) << "\n"; + return OS; +} + +template +raw_ostream &operator<<(raw_ostream &OS, + const FaultMapParser &FMP) { + OS << "Version: " << format_hex(FMP.getFaultMapVersion(), 2) << "\n"; + OS << "NumFunctions: " << FMP.getNumFunctions() << "\n"; + + if (FMP.getNumFunctions() == 0) + return OS; + + typename FaultMapParser::FunctionInfoAccessor FI; + + for (unsigned i = 0, e = FMP.getNumFunctions(); i != e; ++i) { + FI = (i == 0) ? FMP.getFirstFunctionInfo() : FI.getNextFunctionInfo(); + operator<<(OS, FI); + } + + return OS; +} } #endif Index: test/CodeGen/X86/implicit-null-check.ll =================================================================== --- test/CodeGen/X86/implicit-null-check.ll +++ test/CodeGen/X86/implicit-null-check.ll @@ -1,4 +1,6 @@ ; RUN: llc -O3 -mtriple=x86_64-apple-macosx -enable-implicit-null-checks < %s | FileCheck %s +; RUN: llc -O3 -mtriple=x86_64-apple-macosx -enable-implicit-null-checks < %s -filetype=obj -o - | llvm-objdump -fault-map-section - | FileCheck %s -check-prefix=OBJDUMP +; RUN: llc -O3 -mtriple=x86_64-unknown-linux-gnu -enable-implicit-null-checks < %s -filetype=obj -o - | llvm-objdump -fault-map-section - | FileCheck %s -check-prefix=OBJDUMP define i32 @imp_null_check_load(i32* %x) { ; CHECK-LABEL: _imp_null_check_load: @@ -116,3 +118,13 @@ ; CHECK-NEXT: .long Ltmp1-_imp_null_check_load ; Fault[0].HandlerOffset: ; CHECK-NEXT: .long Ltmp0-_imp_null_check_load + +; OBJDUMP: FaultMap table: +; OBJDUMP-NEXT: Version: 0x1 +; OBJDUMP-NEXT: NumFunctions: 3 +; OBJDUMP-NEXT: FunctionAddress: 0x000000, NumFaultingPCs: 1 +; OBJDUMP-NEXT: Fault kind: FaultingLoad, faulting PC offset: 0, handling PC offset: 5 +; OBJDUMP-NEXT: FunctionAddress: 0x000000, NumFaultingPCs: 1 +; OBJDUMP-NEXT: Fault kind: FaultingLoad, faulting PC offset: 0, handling PC offset: 7 +; OBJDUMP-NEXT: FunctionAddress: 0x000000, NumFaultingPCs: 1 +; OBJDUMP-NEXT: Fault kind: FaultingLoad, faulting PC offset: 0, handling PC offset: 3 Index: tools/llvm-objdump/llvm-objdump.cpp =================================================================== --- tools/llvm-objdump/llvm-objdump.cpp +++ tools/llvm-objdump/llvm-objdump.cpp @@ -17,9 +17,11 @@ //===----------------------------------------------------------------------===// #include "llvm-objdump.h" +#include "llvm/ADT/Optional.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/Triple.h" +#include "llvm/CodeGen/FaultMaps.h" #include "llvm/MC/MCAsmInfo.h" #include "llvm/MC/MCContext.h" #include "llvm/MC/MCDisassembler.h" @@ -153,6 +155,9 @@ llvm::PrintImmHex("print-imm-hex", cl::desc("Use hex format for immediate values")); +cl::opt PrintFaultMaps("fault-map-section", + cl::desc("Display contents of faultmap section")); + static StringRef ToolName; static int ReturnValue = EXIT_SUCCESS; @@ -1226,6 +1231,49 @@ } } +static void printFaultMaps(const ObjectFile *Obj) { + const char *FaultMapSectionName = nullptr; + + if (isa(Obj)) { + FaultMapSectionName = ".llvm_faultmaps"; + } else if (isa(Obj)) { + FaultMapSectionName = "__llvm_faultmaps"; + } else { + errs() << "This operation is only currently supported " + "for ELF and Mach-O executable files.\n"; + return; + } + + Optional FaultMapSection; + + for (auto Sec : Obj->sections()) { + StringRef Name; + Sec.getName(Name); + if (Name == FaultMapSectionName) { + FaultMapSection = Sec; + break; + } + } + + outs() << "FaultMap table:\n"; + + if (!FaultMapSection.hasValue()) { + outs() << "\n"; + return; + } + + StringRef FaultMapContents; + if (error(FaultMapSection.getValue().getContents(FaultMapContents))) { + errs() << "Could not read the " << FaultMapContents << " section!\n"; + return; + } + + FaultMapParser FMP(FaultMapContents.bytes_begin(), + FaultMapContents.bytes_end()); + + outs() << FMP; +} + static void printPrivateFileHeader(const ObjectFile *o) { if (o->isELF()) { printELFFileHeader(o); @@ -1265,6 +1313,8 @@ printLazyBindTable(o); if (WeakBind) printWeakBindTable(o); + if (PrintFaultMaps) + printFaultMaps(o); } /// @brief Dump each object file in \a a; @@ -1362,7 +1412,8 @@ && !(DylibsUsed && MachOOpt) && !(DylibId && MachOOpt) && !(ObjcMetaData && MachOOpt) - && !(DumpSections.size() != 0 && MachOOpt)) { + && !(DumpSections.size() != 0 && MachOOpt) + && !PrintFaultMaps) { cl::PrintHelpMessage(); return 2; }