LCOV - code coverage report
Current view: top level - lib/IR - SymbolTableListTraitsImpl.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 35 35 100.0 %
Date: 2018-07-13 00:08:38 Functions: 15 19 78.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- llvm/SymbolTableListTraitsImpl.h - Implementation ------*- C++ -*--===//
       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             : // This file implements the stickier parts of the SymbolTableListTraits class,
      11             : // and is explicitly instantiated where needed to avoid defining all this code
      12             : // in a widely used header.
      13             : //
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #ifndef LLVM_LIB_IR_SYMBOLTABLELISTTRAITSIMPL_H
      17             : #define LLVM_LIB_IR_SYMBOLTABLELISTTRAITSIMPL_H
      18             : 
      19             : #include "llvm/IR/SymbolTableListTraits.h"
      20             : #include "llvm/IR/ValueSymbolTable.h"
      21             : 
      22             : namespace llvm {
      23             : 
      24             : /// setSymTabObject - This is called when (f.e.) the parent of a basic block
      25             : /// changes.  This requires us to remove all the instruction symtab entries from
      26             : /// the current function and reinsert them into the new function.
      27             : template <typename ValueSubClass>
      28             : template <typename TPtr>
      29     2085489 : void SymbolTableListTraits<ValueSubClass>::setSymTabObject(TPtr *Dest,
      30             :                                                            TPtr Src) {
      31             :   // Get the old symtab and value list before doing the assignment.
      32             :   ValueSymbolTable *OldST = getSymTab(getListOwner());
      33             : 
      34             :   // Do it.
      35     2085489 :   *Dest = Src;
      36             :   
      37             :   // Get the new SymTab object.
      38             :   ValueSymbolTable *NewST = getSymTab(getListOwner());
      39             :   
      40             :   // If there is nothing to do, quick exit.
      41     2085489 :   if (OldST == NewST) return;
      42             :   
      43             :   // Move all the elements from the old symtab to the new one.
      44             :   ListTy &ItemList = getList(getListOwner());
      45     1352465 :   if (ItemList.empty()) return;
      46             :   
      47      667827 :   if (OldST) {
      48             :     // Remove all entries from the previous symtab.
      49     4725623 :     for (auto I = ItemList.begin(); I != ItemList.end(); ++I)
      50     4103452 :       if (I->hasName())
      51     1540407 :         OldST->removeValueName(I->getValueName());
      52             :   }
      53             : 
      54      667827 :   if (NewST) {
      55             :     // Add all of the items to the new symtab.
      56      545257 :     for (auto I = ItemList.begin(); I != ItemList.end(); ++I)
      57      498394 :       if (I->hasName())
      58      187351 :         NewST->reinsertValue(&*I);
      59             :   }
      60             :   
      61             : }
      62             : 
      63             : template <typename ValueSubClass>
      64    12142576 : void SymbolTableListTraits<ValueSubClass>::addNodeToList(ValueSubClass *V) {
      65             :   assert(!V->getParent() && "Value already in a container!!");
      66             :   ItemParentClass *Owner = getListOwner();
      67    11308827 :   V->setParent(Owner);
      68    12142576 :   if (V->hasName())
      69     1239281 :     if (ValueSymbolTable *ST = getSymTab(Owner))
      70     1054633 :       ST->reinsertValue(V);
      71    12142576 : }
      72             : 
      73             : template <typename ValueSubClass>
      74     9931190 : void SymbolTableListTraits<ValueSubClass>::removeNodeFromList(
      75             :     ValueSubClass *V) {
      76     9229053 :   V->setParent(nullptr);
      77     9931190 :   if (V->hasName())
      78     3211527 :     if (ValueSymbolTable *ST = getSymTab(getListOwner()))
      79     1671893 :       ST->removeValueName(V->getValueName());
      80     9931190 : }
      81             : 
      82             : template <typename ValueSubClass>
      83      353535 : void SymbolTableListTraits<ValueSubClass>::transferNodesFromList(
      84             :     SymbolTableListTraits &L2, iterator first, iterator last) {
      85             :   // We only have to do work here if transferring instructions between BBs
      86             :   ItemParentClass *NewIP = getListOwner(), *OldIP = L2.getListOwner();
      87             :   assert(NewIP != OldIP && "Expected different list owners");
      88             : 
      89             :   // We only have to update symbol table entries if we are transferring the
      90             :   // instructions to a different symtab object...
      91             :   ValueSymbolTable *NewST = getSymTab(NewIP);
      92             :   ValueSymbolTable *OldST = getSymTab(OldIP);
      93      353535 :   if (NewST != OldST) {
      94        2396 :     for (; first != last; ++first) {
      95             :       ValueSubClass &V = *first;
      96             :       bool HasName = V.hasName();
      97        1243 :       if (OldST && HasName)
      98         599 :         OldST->removeValueName(V.getValueName());
      99        1243 :       V.setParent(NewIP);
     100        1243 :       if (NewST && HasName)
     101         573 :         NewST->reinsertValue(&V);
     102             :     }
     103             :   } else {
     104             :     // Just transferring between blocks in the same function, simply update the
     105             :     // parent fields in the instructions...
     106     2848738 :     for (; first != last; ++first)
     107     2496356 :       first->setParent(NewIP);
     108             :   }
     109      353535 : }
     110             : 
     111             : } // End llvm namespace
     112             : 
     113             : #endif

Generated by: LCOV version 1.13