//===- DynamicExtent.cpp - Dynamic extent related APIs ----------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

//  This file defines APIs that track and query dynamic extent information.

//

//===----------------------------------------------------------------------===//

#include "clang/StaticAnalyzer/Core/PathSensitive/DynamicExtent.h"

#include "clang/AST/Expr.h"

#include "clang/Basic/LLVM.h"

#include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"

#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"

#include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h"

#include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"

#include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"

REGISTER_MAP_WITH_PROGRAMSTATE(DynamicExtentMap, const clang::ento::MemRegion *,

                               clang::ento::DefinedOrUnknownSVal)

namespace clang {

namespace ento {

DefinedOrUnknownSVal getDynamicExtent(ProgramStateRef State,

                                      const MemRegion *MR, SValBuilder &SVB) {

  MR = MR->StripCasts();

  if (const DefinedOrUnknownSVal *Size = State->get<DynamicExtentMap>(MR))

    if (auto SSize =

            SVB.convertToArrayIndex(*Size).getAs<DefinedOrUnknownSVal>())

      return *SSize;

  return MR->getMemRegionManager().getStaticSize(MR, SVB);

}

DefinedOrUnknownSVal getElementExtent(QualType Ty, SValBuilder &SVB) {

  return SVB.makeIntVal(SVB.getContext().getTypeSizeInChars(Ty).getQuantity(),

                        SVB.getArrayIndexType());

}

static DefinedOrUnknownSVal getConstantArrayElementCount(SValBuilder &SVB,

                                                         const MemRegion *MR) {

  MR = MR->StripCasts();

  const auto *TVR = MR->getAs<TypedValueRegion>();

  if (!TVR)

    return UnknownVal();

  if (const ConstantArrayType *CAT =

          SVB.getContext().getAsConstantArrayType(TVR->getValueType()))

    return SVB.makeIntVal(CAT->getSize(), /* isUnsigned = */ false);

  return UnknownVal();

}

static DefinedOrUnknownSVal

getDynamicElementCount(ProgramStateRef State, SVal Size,

                       DefinedOrUnknownSVal ElementSize) {

  SValBuilder &SVB = State->getStateManager().getSValBuilder();

  auto ElementCount =

      SVB.evalBinOp(State, BO_Div, Size, ElementSize, SVB.getArrayIndexType())

          .getAs<DefinedOrUnknownSVal>();

  return ElementCount.value_or(UnknownVal());

}

DefinedOrUnknownSVal getDynamicElementCount(ProgramStateRef State,

                                            const MemRegion *MR,

                                            SValBuilder &SVB,

                                            QualType ElementTy) {

  assert(MR != nullptr && "Not-null region expected");

  MR = MR->StripCasts();

  DefinedOrUnknownSVal ElementSize = getElementExtent(ElementTy, SVB);

  if (ElementSize.isZeroConstant())

    return getConstantArrayElementCount(SVB, MR);

  return getDynamicElementCount(State, getDynamicExtent(State, MR, SVB),

                                ElementSize);

}

SVal getDynamicExtentWithOffset(ProgramStateRef State, SVal BufV) {

  SValBuilder &SVB = State->getStateManager().getSValBuilder();

  const MemRegion *MRegion = BufV.getAsRegion();

  if (!MRegion)

    return UnknownVal();

  RegionOffset Offset = MRegion->getAsOffset();

  if (Offset.hasSymbolicOffset())

    return UnknownVal();

  const MemRegion *BaseRegion = MRegion->getBaseRegion();

  if (!BaseRegion)

    return UnknownVal();

  NonLoc OffsetInChars =

      SVB.makeArrayIndex(Offset.getOffset() / SVB.getContext().getCharWidth());

  DefinedOrUnknownSVal ExtentInBytes = getDynamicExtent(State, BaseRegion, SVB);

  return SVB.evalBinOp(State, BinaryOperator::Opcode::BO_Sub, ExtentInBytes,

                       OffsetInChars, SVB.getArrayIndexType());

}

DefinedOrUnknownSVal getDynamicElementCountWithOffset(ProgramStateRef State,

                                                      SVal BufV,

                                                      QualType ElementTy) {

  const MemRegion *MR = BufV.getAsRegion();

  if (!MR)

    return UnknownVal();

  SValBuilder &SVB = State->getStateManager().getSValBuilder();

  DefinedOrUnknownSVal ElementSize = getElementExtent(ElementTy, SVB);

  if (ElementSize.isZeroConstant())

    return getConstantArrayElementCount(SVB, MR);

  return getDynamicElementCount(State, getDynamicExtentWithOffset(State, BufV),

                                ElementSize);

}

ProgramStateRef setDynamicExtent(ProgramStateRef State, const MemRegion *MR,

                                 DefinedOrUnknownSVal Size, SValBuilder &SVB) {

  MR = MR->StripCasts();

  if (Size.isUnknown())

    return State;

  return State->set<DynamicExtentMap>(MR->StripCasts(), Size);

}

} // namespace ento

} // namespace clang