compilerbitsettraits.hpp

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

#ifndef CompilerBitSetTraits_HPP_DEFINED
#defineCompilerBitSetTraits_HPP_DEFINED1

#include"compilerbitsettraits.h"
#include"compiler.h"

///////////////////////////////////////////////////////////////////////////////
//
// CompAllocBitSetTraits
//
///////////////////////////////////////////////////////////////////////////////

// static
void* CompAllocBitSetTraits::Alloc(Compiler* comp, size_t byteSize)
{
return comp->getAllocator(CMK_bitset).allocate<char>(byteSize);
}

#ifdef DEBUG
// static
void* CompAllocBitSetTraits::DebugAlloc(Compiler* comp, size_t byteSize)
{
return comp->getAllocator(CMK_DebugOnly).allocate<char>(byteSize);
}
#endif// DEBUG

///////////////////////////////////////////////////////////////////////////////
//
// TrackedVarBitSetTraits
//
///////////////////////////////////////////////////////////////////////////////

// static
unsignedTrackedVarBitSetTraits::GetSize(Compiler* comp)
{
return comp->lvaTrackedCount;
}

// static
unsignedTrackedVarBitSetTraits::GetArrSize(Compiler* comp, unsigned elemSize)
{
assert(elemSize == sizeof(size_t));
return comp->lvaTrackedCountInSizeTUnits;
}

// static
unsignedTrackedVarBitSetTraits::GetEpoch(Compiler* comp)
{
return comp->GetCurLVEpoch();
}

// static
BitSetSupport::BitSetOpCounter* TrackedVarBitSetTraits::GetOpCounter(Compiler* comp)
{
#if VARSET_COUNTOPS
return &Compiler::m_varsetOpCounter;
#else
returnnullptr;
#endif
}

///////////////////////////////////////////////////////////////////////////////
//
// AllVarBitSetTraits
//
///////////////////////////////////////////////////////////////////////////////

// static
unsignedAllVarBitSetTraits::GetSize(Compiler* comp)
{
returnmin(comp->lvaCount, lclMAX_ALLSET_TRACKED);
}

// static
unsignedAllVarBitSetTraits::GetArrSize(Compiler* comp, unsigned elemSize)
{
returnroundUp(GetSize(comp), elemSize);
}

// static
unsignedAllVarBitSetTraits::GetEpoch(Compiler* comp)
{
returnGetSize(comp);
}

// static
BitSetSupport::BitSetOpCounter* AllVarBitSetTraits::GetOpCounter(Compiler* comp)
{
#if ALLVARSET_COUNTOPS
return &Compiler::m_allvarsetOpCounter;
#else
returnnullptr;
#endif
}

///////////////////////////////////////////////////////////////////////////////
//
// BasicBlockBitSetTraits
//
///////////////////////////////////////////////////////////////////////////////

// static
unsignedBasicBlockBitSetTraits::GetSize(Compiler* comp)
{
return comp->fgCurBBEpochSize;
}

// static
unsignedBasicBlockBitSetTraits::GetArrSize(Compiler* comp, unsigned elemSize)
{
// Assert that the epoch has been initialized. This is a convenient place to assert this because
// GetArrSize() is called for every function, via IsShort().
assert(GetEpoch(comp) != 0);

assert(elemSize == sizeof(size_t));
return comp->fgBBSetCountInSizeTUnits; // This is precomputed to avoid doing math every time this function is called
}

// static
unsignedBasicBlockBitSetTraits::GetEpoch(Compiler* comp)
{
return comp->GetCurBasicBlockEpoch();
}

// static
BitSetSupport::BitSetOpCounter* BasicBlockBitSetTraits::GetOpCounter(Compiler* comp)
{
returnnullptr;
}

///////////////////////////////////////////////////////////////////////////////
//
// BitVecTraits
//
///////////////////////////////////////////////////////////////////////////////

// static
void* BitVecTraits::Alloc(BitVecTraits* b, size_t byteSize)
{
return b->comp->getAllocator(CMK_bitset).allocate<char>(byteSize);
}

#ifdef DEBUG
// static
void* BitVecTraits::DebugAlloc(BitVecTraits* b, size_t byteSize)
{
return b->comp->getAllocator(CMK_DebugOnly).allocate<char>(byteSize);
}
#endif// DEBUG

// static
unsignedBitVecTraits::GetSize(BitVecTraits* b)
{
return b->size;
}

// static
unsignedBitVecTraits::GetArrSize(BitVecTraits* b, unsigned elemSize)
{
assert(elemSize == sizeof(size_t));
unsigned elemBits = 8 * elemSize;
returnroundUp(b->size, elemBits) / elemBits;
}

// static
unsignedBitVecTraits::GetEpoch(BitVecTraits* b)
{
return b->size;
}

// static
BitSetSupport::BitSetOpCounter* BitVecTraits::GetOpCounter(BitVecTraits* b)
{
returnnullptr;
}

#endif// CompilerBitSetTraits_HPP_DEFINED