LCOV - code coverage report
Current view: top level - lib/Object - RecordStreamer.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 54 60 90.0 %
Date: 2018-02-23 15:42:53 Functions: 12 14 85.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- RecordStreamer.cpp - Record asm defined and used symbols ----------===//
       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 "RecordStreamer.h"
      11             : #include "llvm/MC/MCSymbol.h"
      12             : 
      13             : using namespace llvm;
      14             : 
      15         182 : void RecordStreamer::markDefined(const MCSymbol &Symbol) {
      16         182 :   State &S = Symbols[Symbol.getName()];
      17         182 :   switch (S) {
      18          44 :   case DefinedGlobal:
      19             :   case Global:
      20          44 :     S = DefinedGlobal;
      21          44 :     break;
      22         123 :   case NeverSeen:
      23             :   case Defined:
      24             :   case Used:
      25         123 :     S = Defined;
      26         123 :     break;
      27             :   case DefinedWeak:
      28             :     break;
      29          15 :   case UndefinedWeak:
      30          15 :     S = DefinedWeak;
      31             :   }
      32         182 : }
      33             : 
      34         117 : void RecordStreamer::markGlobal(const MCSymbol &Symbol,
      35             :                                 MCSymbolAttr Attribute) {
      36         117 :   State &S = Symbols[Symbol.getName()];
      37         117 :   switch (S) {
      38          50 :   case DefinedGlobal:
      39             :   case Defined:
      40          50 :     S = (Attribute == MCSA_Weak) ? DefinedWeak : DefinedGlobal;
      41          50 :     break;
      42             : 
      43          67 :   case NeverSeen:
      44             :   case Global:
      45             :   case Used:
      46          67 :     S = (Attribute == MCSA_Weak) ? UndefinedWeak : Global;
      47          67 :     break;
      48             :   case UndefinedWeak:
      49             :   case DefinedWeak:
      50             :     break;
      51             :   }
      52         117 : }
      53             : 
      54         136 : void RecordStreamer::markUsed(const MCSymbol &Symbol) {
      55         136 :   State &S = Symbols[Symbol.getName()];
      56         136 :   switch (S) {
      57             :   case DefinedGlobal:
      58             :   case Defined:
      59             :   case Global:
      60             :   case DefinedWeak:
      61             :   case UndefinedWeak:
      62             :     break;
      63             : 
      64         115 :   case NeverSeen:
      65             :   case Used:
      66         115 :     S = Used;
      67         115 :     break;
      68             :   }
      69         136 : }
      70             : 
      71         134 : void RecordStreamer::visitUsedSymbol(const MCSymbol &Sym) { markUsed(Sym); }
      72             : 
      73         255 : RecordStreamer::RecordStreamer(MCContext &Context) : MCStreamer(Context) {}
      74             : 
      75          85 : RecordStreamer::const_iterator RecordStreamer::begin() {
      76         170 :   return Symbols.begin();
      77             : }
      78             : 
      79         170 : RecordStreamer::const_iterator RecordStreamer::end() { return Symbols.end(); }
      80             : 
      81          94 : void RecordStreamer::EmitInstruction(const MCInst &Inst,
      82             :                                      const MCSubtargetInfo &STI, bool) {
      83          94 :   MCStreamer::EmitInstruction(Inst, STI);
      84          94 : }
      85             : 
      86          99 : void RecordStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
      87          99 :   MCStreamer::EmitLabel(Symbol);
      88          99 :   markDefined(*Symbol);
      89          99 : }
      90             : 
      91          83 : void RecordStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
      92          83 :   markDefined(*Symbol);
      93          83 :   MCStreamer::EmitAssignment(Symbol, Value);
      94          83 : }
      95             : 
      96         190 : bool RecordStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
      97             :                                          MCSymbolAttr Attribute) {
      98         190 :   if (Attribute == MCSA_Global || Attribute == MCSA_Weak)
      99         117 :     markGlobal(*Symbol, Attribute);
     100         190 :   if (Attribute == MCSA_LazyReference)
     101           2 :     markUsed(*Symbol);
     102         190 :   return true;
     103             : }
     104             : 
     105           0 : void RecordStreamer::EmitZerofill(MCSection *Section, MCSymbol *Symbol,
     106             :                                   uint64_t Size, unsigned ByteAlignment) {
     107           0 :   markDefined(*Symbol);
     108           0 : }
     109             : 
     110           0 : void RecordStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
     111             :                                       unsigned ByteAlignment) {
     112           0 :   markDefined(*Symbol);
     113           0 : }
     114             : 
     115          56 : void RecordStreamer::emitELFSymverDirective(MCSymbol *Alias,
     116             :                                             const MCSymbol *Aliasee) {
     117         112 :   SymverAliasMap[Aliasee].push_back(Alias);
     118          56 : }

Generated by: LCOV version 1.13