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