1 //===- FaultMaps.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 "llvm/CodeGen/FaultMaps.h" 11 #include "llvm/ADT/Twine.h" 12 #include "llvm/CodeGen/AsmPrinter.h" 13 #include "llvm/MC/MCContext.h" 14 #include "llvm/MC/MCExpr.h" 15 #include "llvm/MC/MCObjectFileInfo.h" 16 #include "llvm/MC/MCStreamer.h" 17 #include "llvm/Support/Debug.h" 18 #include "llvm/Support/ErrorHandling.h" 19 #include "llvm/Support/Format.h" 20 #include "llvm/Support/raw_ostream.h" 21 22 using namespace llvm; 23 24 #define DEBUG_TYPE "faultmaps" 25 26 static const int FaultMapVersion = 1; 27 const char *FaultMaps::WFMP = "Fault Maps: "; 28 29 FaultMaps::FaultMaps(AsmPrinter &AP) : AP(AP) {} 30 31 void FaultMaps::recordFaultingOp(FaultKind FaultTy, 32 const MCSymbol *HandlerLabel) { 33 MCContext &OutContext = AP.OutStreamer->getContext(); 34 MCSymbol *FaultingLabel = OutContext.createTempSymbol(); 35 36 AP.OutStreamer->EmitLabel(FaultingLabel); 37 38 const MCExpr *FaultingOffset = MCBinaryExpr::createSub( 39 MCSymbolRefExpr::create(FaultingLabel, OutContext), 40 MCSymbolRefExpr::create(AP.CurrentFnSymForSize, OutContext), OutContext); 41 42 const MCExpr *HandlerOffset = MCBinaryExpr::createSub( 43 MCSymbolRefExpr::create(HandlerLabel, OutContext), 44 MCSymbolRefExpr::create(AP.CurrentFnSymForSize, OutContext), OutContext); 45 46 FunctionInfos[AP.CurrentFnSym].emplace_back(FaultTy, FaultingOffset, 47 HandlerOffset); 48 } 49 50 void FaultMaps::serializeToFaultMapSection() { 51 if (FunctionInfos.empty()) 52 return; 53 54 MCContext &OutContext = AP.OutStreamer->getContext(); 55 MCStreamer &OS = *AP.OutStreamer; 56 57 // Create the section. 58 MCSection *FaultMapSection = 59 OutContext.getObjectFileInfo()->getFaultMapSection(); 60 OS.SwitchSection(FaultMapSection); 61 62 // Emit a dummy symbol to force section inclusion. 63 OS.EmitLabel(OutContext.getOrCreateSymbol(Twine("__LLVM_FaultMaps"))); 64 65 LLVM_DEBUG(dbgs() << "********** Fault Map Output **********\n"); 66 67 // Header 68 OS.EmitIntValue(FaultMapVersion, 1); // Version. 69 OS.EmitIntValue(0, 1); // Reserved. 70 OS.EmitIntValue(0, 2); // Reserved. 71 72 LLVM_DEBUG(dbgs() << WFMP << "#functions = " << FunctionInfos.size() << "\n"); 73 OS.EmitIntValue(FunctionInfos.size(), 4); 74 75 LLVM_DEBUG(dbgs() << WFMP << "functions:\n"); 76 77 for (const auto &FFI : FunctionInfos) 78 emitFunctionInfo(FFI.first, FFI.second); 79 } 80 81 void FaultMaps::emitFunctionInfo(const MCSymbol *FnLabel, 82 const FunctionFaultInfos &FFI) { 83 MCStreamer &OS = *AP.OutStreamer; 84 85 LLVM_DEBUG(dbgs() << WFMP << " function addr: " << *FnLabel << "\n"); 86 OS.EmitSymbolValue(FnLabel, 8); 87 88 LLVM_DEBUG(dbgs() << WFMP << " #faulting PCs: " << FFI.size() << "\n"); 89 OS.EmitIntValue(FFI.size(), 4); 90 91 OS.EmitIntValue(0, 4); // Reserved 92 93 for (auto &Fault : FFI) { 94 LLVM_DEBUG(dbgs() << WFMP << " fault type: " 95 << faultTypeToString(Fault.Kind) << "\n"); 96 OS.EmitIntValue(Fault.Kind, 4); 97 98 LLVM_DEBUG(dbgs() << WFMP << " faulting PC offset: " 99 << *Fault.FaultingOffsetExpr << "\n"); 100 OS.EmitValue(Fault.FaultingOffsetExpr, 4); 101 102 LLVM_DEBUG(dbgs() << WFMP << " fault handler PC offset: " 103 << *Fault.HandlerOffsetExpr << "\n"); 104 OS.EmitValue(Fault.HandlerOffsetExpr, 4); 105 } 106 } 107 108 const char *FaultMaps::faultTypeToString(FaultMaps::FaultKind FT) { 109 switch (FT) { 110 default: 111 llvm_unreachable("unhandled fault type!"); 112 case FaultMaps::FaultingLoad: 113 return "FaultingLoad"; 114 case FaultMaps::FaultingLoadStore: 115 return "FaultingLoadStore"; 116 case FaultMaps::FaultingStore: 117 return "FaultingStore"; 118 } 119 } 120 121 raw_ostream &llvm:: 122 operator<<(raw_ostream &OS, 123 const FaultMapParser::FunctionFaultInfoAccessor &FFI) { 124 OS << "Fault kind: " 125 << FaultMaps::faultTypeToString((FaultMaps::FaultKind)FFI.getFaultKind()) 126 << ", faulting PC offset: " << FFI.getFaultingPCOffset() 127 << ", handling PC offset: " << FFI.getHandlerPCOffset(); 128 return OS; 129 } 130 131 raw_ostream &llvm:: 132 operator<<(raw_ostream &OS, const FaultMapParser::FunctionInfoAccessor &FI) { 133 OS << "FunctionAddress: " << format_hex(FI.getFunctionAddr(), 8) 134 << ", NumFaultingPCs: " << FI.getNumFaultingPCs() << "\n"; 135 for (unsigned i = 0, e = FI.getNumFaultingPCs(); i != e; ++i) 136 OS << FI.getFunctionFaultInfoAt(i) << "\n"; 137 return OS; 138 } 139 140 raw_ostream &llvm::operator<<(raw_ostream &OS, const FaultMapParser &FMP) { 141 OS << "Version: " << format_hex(FMP.getFaultMapVersion(), 2) << "\n"; 142 OS << "NumFunctions: " << FMP.getNumFunctions() << "\n"; 143 144 if (FMP.getNumFunctions() == 0) 145 return OS; 146 147 FaultMapParser::FunctionInfoAccessor FI; 148 149 for (unsigned i = 0, e = FMP.getNumFunctions(); i != e; ++i) { 150 FI = (i == 0) ? FMP.getFirstFunctionInfo() : FI.getNextFunctionInfo(); 151 OS << FI; 152 } 153 154 return OS; 155 } 156