LCOV - code coverage report
Current view: top level - lib/IR - User.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 64 67 95.5 %
Date: 2018-06-17 00:07:59 Functions: 8 9 88.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- User.cpp - Implement the User class -------------------------------===//
       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/IR/User.h"
      11             : #include "llvm/IR/Constant.h"
      12             : #include "llvm/IR/GlobalValue.h"
      13             : 
      14             : namespace llvm {
      15             : class BasicBlock;
      16             : 
      17             : //===----------------------------------------------------------------------===//
      18             : //                                 User Class
      19             : //===----------------------------------------------------------------------===//
      20             : 
      21       64538 : void User::replaceUsesOfWith(Value *From, Value *To) {
      22       64538 :   if (From == To) return;   // Duh what?
      23             : 
      24             :   assert((!isa<Constant>(this) || isa<GlobalValue>(this)) &&
      25             :          "Cannot call User::replaceUsesOfWith on a constant!");
      26             : 
      27      343807 :   for (unsigned i = 0, E = getNumOperands(); i != E; ++i)
      28      141029 :     if (getOperand(i) == From) {  // Is This operand is pointing to oldval?
      29             :       // The side effects of this setOperand call include linking to
      30             :       // "To", adding "this" to the uses list of To, and
      31             :       // most importantly, removing "this" from the use list of "From".
      32       60553 :       setOperand(i, To); // Fix it now...
      33             :     }
      34             : }
      35             : 
      36             : //===----------------------------------------------------------------------===//
      37             : //                         User allocHungoffUses Implementation
      38             : //===----------------------------------------------------------------------===//
      39             : 
      40      347230 : void User::allocHungoffUses(unsigned N, bool IsPhi) {
      41             :   assert(HasHungOffUses && "alloc must have hung off uses");
      42             : 
      43             :   static_assert(alignof(Use) >= alignof(Use::UserRef),
      44             :                 "Alignment is insufficient for 'hung-off-uses' pieces");
      45             :   static_assert(alignof(Use::UserRef) >= alignof(BasicBlock *),
      46             :                 "Alignment is insufficient for 'hung-off-uses' pieces");
      47             : 
      48             :   // Allocate the array of Uses, followed by a pointer (with bottom bit set) to
      49             :   // the User.
      50      347230 :   size_t size = N * sizeof(Use) + sizeof(Use::UserRef);
      51      347230 :   if (IsPhi)
      52      282589 :     size += N * sizeof(BasicBlock *);
      53      347230 :   Use *Begin = static_cast<Use*>(::operator new(size));
      54      347230 :   Use *End = Begin + N;
      55      347230 :   (void) new(End) Use::UserRef(const_cast<User*>(this), 1);
      56      347230 :   setOperandList(Use::initTags(Begin, End));
      57      347230 : }
      58             : 
      59       66378 : void User::growHungoffUses(unsigned NewNumUses, bool IsPhi) {
      60             :   assert(HasHungOffUses && "realloc must have hung off uses");
      61             : 
      62             :   unsigned OldNumUses = getNumOperands();
      63             : 
      64             :   // We don't support shrinking the number of uses.  We wouldn't have enough
      65             :   // space to copy the old uses in to the new space.
      66             :   assert(NewNumUses > OldNumUses && "realloc must grow num uses");
      67             : 
      68             :   Use *OldOps = getOperandList();
      69       66378 :   allocHungoffUses(NewNumUses, IsPhi);
      70             :   Use *NewOps = getOperandList();
      71             : 
      72             :   // Now copy from the old operands list to the new one.
      73       66378 :   std::copy(OldOps, OldOps + OldNumUses, NewOps);
      74             : 
      75             :   // If this is a Phi, then we need to copy the BB pointers too.
      76       66378 :   if (IsPhi) {
      77       59646 :     auto *OldPtr =
      78             :         reinterpret_cast<char *>(OldOps + OldNumUses) + sizeof(Use::UserRef);
      79       59646 :     auto *NewPtr =
      80       59646 :         reinterpret_cast<char *>(NewOps + NewNumUses) + sizeof(Use::UserRef);
      81       59646 :     std::copy(OldPtr, OldPtr + (OldNumUses * sizeof(BasicBlock *)), NewPtr);
      82             :   }
      83       66378 :   Use::zap(OldOps, OldOps + OldNumUses, true);
      84       66378 : }
      85             : 
      86             : 
      87             : // This is a private struct used by `User` to track the co-allocated descriptor
      88             : // section.
      89             : struct DescriptorInfo {
      90             :   intptr_t SizeInBytes;
      91             : };
      92             : 
      93           0 : ArrayRef<const uint8_t> User::getDescriptor() const {
      94           0 :   auto MutableARef = const_cast<User *>(this)->getDescriptor();
      95           0 :   return {MutableARef.begin(), MutableARef.end()};
      96             : }
      97             : 
      98       86230 : MutableArrayRef<uint8_t> User::getDescriptor() {
      99             :   assert(HasDescriptor && "Don't call otherwise!");
     100             :   assert(!HasHungOffUses && "Invariant!");
     101             : 
     102             :   auto *DI = reinterpret_cast<DescriptorInfo *>(getIntrusiveOperands()) - 1;
     103             :   assert(DI->SizeInBytes != 0 && "Should not have had a descriptor otherwise!");
     104             : 
     105       86230 :   return MutableArrayRef<uint8_t>(
     106      172460 :       reinterpret_cast<uint8_t *>(DI) - DI->SizeInBytes, DI->SizeInBytes);
     107             : }
     108             : 
     109             : //===----------------------------------------------------------------------===//
     110             : //                         User operator new Implementations
     111             : //===----------------------------------------------------------------------===//
     112             : 
     113             : void *User::allocateFixedOperandUser(size_t Size, unsigned Us,
     114             :                                      unsigned DescBytes) {
     115             :   assert(Us < (1u << NumUserOperandsBits) && "Too many operands");
     116             : 
     117             :   static_assert(sizeof(DescriptorInfo) % sizeof(void *) == 0, "Required below");
     118             : 
     119      866289 :   unsigned DescBytesToAllocate =
     120             :       DescBytes == 0 ? 0 : (DescBytes + sizeof(DescriptorInfo));
     121             :   assert(DescBytesToAllocate % sizeof(void *) == 0 &&
     122             :          "We need this to satisfy alignment constraints for Uses");
     123             : 
     124             :   uint8_t *Storage = static_cast<uint8_t *>(
     125    12648272 :       ::operator new(Size + sizeof(Use) * Us + DescBytesToAllocate));
     126      866289 :   Use *Start = reinterpret_cast<Use *>(Storage + DescBytesToAllocate);
     127    12648273 :   Use *End = Start + Us;
     128             :   User *Obj = reinterpret_cast<User*>(End);
     129    12648273 :   Obj->NumUserOperands = Us;
     130    12648273 :   Obj->HasHungOffUses = false;
     131    12648273 :   Obj->HasDescriptor = DescBytes != 0;
     132    12648273 :   Use::initTags(Start, End);
     133             : 
     134      866289 :   if (DescBytes != 0) {
     135        1707 :     auto *DescInfo = reinterpret_cast<DescriptorInfo *>(Storage + DescBytes);
     136        1707 :     DescInfo->SizeInBytes = DescBytes;
     137             :   }
     138             : 
     139             :   return Obj;
     140             : }
     141             : 
     142    11781983 : void *User::operator new(size_t Size, unsigned Us) {
     143    11781983 :   return allocateFixedOperandUser(Size, Us, 0);
     144             : }
     145             : 
     146      866289 : void *User::operator new(size_t Size, unsigned Us, unsigned DescBytes) {
     147      866289 :   return allocateFixedOperandUser(Size, Us, DescBytes);
     148             : }
     149             : 
     150      891412 : void *User::operator new(size_t Size) {
     151             :   // Allocate space for a single Use*
     152      891412 :   void *Storage = ::operator new(Size + sizeof(Use *));
     153             :   Use **HungOffOperandList = static_cast<Use **>(Storage);
     154      891412 :   User *Obj = reinterpret_cast<User *>(HungOffOperandList + 1);
     155      891412 :   Obj->NumUserOperands = 0;
     156      891412 :   Obj->HasHungOffUses = true;
     157      891412 :   Obj->HasDescriptor = false;
     158      891412 :   *HungOffOperandList = nullptr;
     159      891412 :   return Obj;
     160             : }
     161             : 
     162             : //===----------------------------------------------------------------------===//
     163             : //                         User operator delete Implementation
     164             : //===----------------------------------------------------------------------===//
     165             : 
     166    10849656 : void User::operator delete(void *Usr) {
     167             :   // Hung off uses use a single Use* before the User, while other subclasses
     168             :   // use a Use[] allocated prior to the user.
     169             :   User *Obj = static_cast<User *>(Usr);
     170    10849656 :   if (Obj->HasHungOffUses) {
     171             :     assert(!Obj->HasDescriptor && "not supported!");
     172             : 
     173      759011 :     Use **HungOffOperandList = static_cast<Use **>(Usr) - 1;
     174             :     // drop the hung off uses.
     175      759011 :     Use::zap(*HungOffOperandList, *HungOffOperandList + Obj->NumUserOperands,
     176             :              /* Delete */ true);
     177      759011 :     ::operator delete(HungOffOperandList);
     178    10090645 :   } else if (Obj->HasDescriptor) {
     179        1706 :     Use *UseBegin = static_cast<Use *>(Usr) - Obj->NumUserOperands;
     180        1706 :     Use::zap(UseBegin, UseBegin + Obj->NumUserOperands, /* Delete */ false);
     181             : 
     182             :     auto *DI = reinterpret_cast<DescriptorInfo *>(UseBegin) - 1;
     183        1706 :     uint8_t *Storage = reinterpret_cast<uint8_t *>(DI) - DI->SizeInBytes;
     184        1706 :     ::operator delete(Storage);
     185             :   } else {
     186    10088939 :     Use *Storage = static_cast<Use *>(Usr) - Obj->NumUserOperands;
     187    10088939 :     Use::zap(Storage, Storage + Obj->NumUserOperands,
     188             :              /* Delete */ false);
     189    10088939 :     ::operator delete(Storage);
     190             :   }
     191    10849656 : }
     192             : 
     193             : } // End llvm namespace

Generated by: LCOV version 1.13