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