// 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
#define CompilerBitSetTraits_HPP_DEFINED 1

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

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

// static
void* CompAllocBitSetTraits::Alloc(Compiler* comp, size_t byteSize)
{
    return comp->compGetMem(byteSize, CMK_bitset);
}

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

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

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

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

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

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

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

// static
unsigned AllVarBitSetTraits::GetSize(Compiler* comp)
{
    return min(comp->lvaCount, lclMAX_ALLSET_TRACKED);
}

// static
unsigned AllVarBitSetTraits::GetArrSize(Compiler* comp, unsigned elemSize)
{
    return unsigned(roundUp(GetSize(comp), elemSize));
}

// static
unsigned AllVarBitSetTraits::GetEpoch(Compiler* comp)
{
    return GetSize(comp);
}

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

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

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

// static
unsigned BasicBlockBitSetTraits::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
unsigned BasicBlockBitSetTraits::GetEpoch(Compiler* comp)
{
    return comp->GetCurBasicBlockEpoch();
}

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

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

// static
void* BitVecTraits::Alloc(BitVecTraits* b, size_t byteSize)
{
    return b->comp->compGetMem(byteSize, CMK_bitset);
}

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

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

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

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

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

#endif // CompilerBitSetTraits_HPP_DEFINED