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: 2017-09-14 15:23:50 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         195 : void RecordStreamer::markDefined(const MCSymbol &Symbol) {
      16         390 :   State &S = Symbols[Symbol.getName()];
      17         195 :   switch (S) {
      18          49 :   case DefinedGlobal:
      19             :   case Global:
      20          49 :     S = DefinedGlobal;
      21          49 :     break;
      22         129 :   case NeverSeen:
      23             :   case Defined:
      24             :   case Used:
      25         129 :     S = Defined;
      26         129 :     break;
      27             :   case DefinedWeak:
      28             :     break;
      29          17 :   case UndefinedWeak:
      30          17 :     S = DefinedWeak;
      31             :   }
      32         195 : }
      33             : 
      34         124 : void RecordStreamer::markGlobal(const MCSymbol &Symbol,
      35             :                                 MCSymbolAttr Attribute) {
      36         248 :   State &S = Symbols[Symbol.getName()];
      37         124 :   switch (S) {
      38          50 :   case DefinedGlobal:
      39             :   case Defined:
      40          50 :     S = (Attribute == MCSA_Weak) ? DefinedWeak : DefinedGlobal;
      41          50 :     break;
      42             : 
      43          74 :   case NeverSeen:
      44             :   case Global:
      45             :   case Used:
      46          74 :     S = (Attribute == MCSA_Weak) ? UndefinedWeak : Global;
      47          74 :     break;
      48             :   case UndefinedWeak:
      49             :   case DefinedWeak:
      50             :     break;
      51             :   }
      52         124 : }
      53             : 
      54         149 : void RecordStreamer::markUsed(const MCSymbol &Symbol) {
      55         298 :   State &S = Symbols[Symbol.getName()];
      56         149 :   switch (S) {
      57             :   case DefinedGlobal:
      58             :   case Defined:
      59             :   case Global:
      60             :   case DefinedWeak:
      61             :   case UndefinedWeak:
      62             :     break;
      63             : 
      64         128 :   case NeverSeen:
      65             :   case Used:
      66         128 :     S = Used;
      67         128 :     break;
      68             :   }
      69         149 : }
      70             : 
      71         147 : void RecordStreamer::visitUsedSymbol(const MCSymbol &Sym) { markUsed(Sym); }
      72             : 
      73         258 : RecordStreamer::RecordStreamer(MCContext &Context) : MCStreamer(Context) {}
      74             : 
      75          86 : RecordStreamer::const_iterator RecordStreamer::begin() {
      76         258 :   return Symbols.begin();
      77             : }
      78             : 
      79         258 : RecordStreamer::const_iterator RecordStreamer::end() { return Symbols.end(); }
      80             : 
      81         112 : void RecordStreamer::EmitInstruction(const MCInst &Inst,
      82             :                                      const MCSubtargetInfo &STI, bool) {
      83         112 :   MCStreamer::EmitInstruction(Inst, STI);
      84         112 : }
      85             : 
      86         115 : void RecordStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
      87         115 :   MCStreamer::EmitLabel(Symbol);
      88         115 :   markDefined(*Symbol);
      89         115 : }
      90             : 
      91          80 : void RecordStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
      92          80 :   markDefined(*Symbol);
      93          80 :   MCStreamer::EmitAssignment(Symbol, Value);
      94          80 : }
      95             : 
      96         206 : bool RecordStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
      97             :                                          MCSymbolAttr Attribute) {
      98         206 :   if (Attribute == MCSA_Global || Attribute == MCSA_Weak)
      99         124 :     markGlobal(*Symbol, Attribute);
     100         206 :   if (Attribute == MCSA_LazyReference)
     101           2 :     markUsed(*Symbol);
     102         206 :   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