LCOV - code coverage report
Current view: top level - lib/IR - SymbolTableListTraitsImpl.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 44 44 100.0 %
Date: 2017-09-14 15:23:50 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     1518016 : void SymbolTableListTraits<ValueSubClass>::setSymTabObject(TPtr *Dest,
      30             :                                                            TPtr Src) {
      31             :   // Get the old symtab and value list before doing the assignment.
      32     3036031 :   ValueSymbolTable *OldST = getSymTab(getListOwner());
      33             : 
      34             :   // Do it.
      35     1518015 :   *Dest = Src;
      36             :   
      37             :   // Get the new SymTab object.
      38     3036030 :   ValueSymbolTable *NewST = getSymTab(getListOwner());
      39             :   
      40             :   // If there is nothing to do, quick exit.
      41     1518015 :   if (OldST == NewST) return;
      42             :   
      43             :   // Move all the elements from the old symtab to the new one.
      44     1865306 :   ListTy &ItemList = getList(getListOwner());
      45     1865306 :   if (ItemList.empty()) return;
      46             :   
      47      458934 :   if (OldST) {
      48             :     // Remove all entries from the previous symtab.
      49     3812522 :     for (auto I = ItemList.begin(); I != ItemList.end(); ++I)
      50     5132200 :       if (I->hasName())
      51      957261 :         OldST->removeValueName(I->getValueName());
      52             :   }
      53             : 
      54      458934 :   if (NewST) {
      55             :     // Add all of the items to the new symtab.
      56      590543 :     for (auto I = ItemList.begin(); I != ItemList.end(); ++I)
      57      913300 :       if (I->hasName())
      58      171550 :         NewST->reinsertValue(&*I);
      59             :   }
      60             :   
      61             : }
      62             : 
      63             : template <typename ValueSubClass>
      64     8937538 : void SymbolTableListTraits<ValueSubClass>::addNodeToList(ValueSubClass *V) {
      65             :   assert(!V->getParent() && "Value already in a container!!");
      66     8937538 :   ItemParentClass *Owner = getListOwner();
      67     9513337 :   V->setParent(Owner);
      68    17875076 :   if (V->hasName())
      69      793180 :     if (ValueSymbolTable *ST = getSymTab(Owner))
      70      623909 :       ST->reinsertValue(V);
      71     8937538 : }
      72             : 
      73             : template <typename ValueSubClass>
      74     7438864 : void SymbolTableListTraits<ValueSubClass>::removeNodeFromList(
      75             :     ValueSubClass *V) {
      76     7945355 :   V->setParent(nullptr);
      77    14877728 :   if (V->hasName())
      78     4067595 :     if (ValueSymbolTable *ST = getSymTab(getListOwner()))
      79     1077283 :       ST->removeValueName(V->getValueName());
      80     7438864 : }
      81             : 
      82             : template <typename ValueSubClass>
      83      316746 : 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      633492 :   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      316746 :   ValueSymbolTable *NewST = getSymTab(NewIP);
      92      316746 :   ValueSymbolTable *OldST = getSymTab(OldIP);
      93      316746 :   if (NewST != OldST) {
      94        2334 :     for (; first != last; ++first) {
      95        1207 :       ValueSubClass &V = *first;
      96        2414 :       bool HasName = V.hasName();
      97        1207 :       if (OldST && HasName)
      98         345 :         OldST->removeValueName(V.getValueName());
      99        1207 :       V.setParent(NewIP);
     100        1207 :       if (NewST && HasName)
     101         319 :         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     2573901 :     for (; first != last; ++first)
     107     2258282 :       first->setParent(NewIP);
     108             :   }
     109      316746 : }
     110             : 
     111             : } // End llvm namespace
     112             : 
     113             : #endif

Generated by: LCOV version 1.13