llvm-project/clang/lib/Analysis/FlowSensitive/RecordOps.cpp

//===-- RecordOps.cpp -------------------------------------------*- 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
//
//===----------------------------------------------------------------------===//
//
//  Operations on records (structs, classes, and unions).
//
//===----------------------------------------------------------------------===//

#include "clang/Analysis/FlowSensitive/RecordOps.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/Type.h"
#include "clang/Analysis/FlowSensitive/ASTOps.h"
#include "clang/Basic/LLVM.h"
#include "llvm/ADT/StringMap.h"

#define DEBUG_TYPE "dataflow"

namespace clang::dataflow {

static void copyField(const ValueDecl &Field, StorageLocation *SrcFieldLoc,
                      StorageLocation *DstFieldLoc, RecordStorageLocation &Dst,
                      Environment &Env) {
  assert(Field.getType()->isReferenceType() ||
         (SrcFieldLoc != nullptr && DstFieldLoc != nullptr));

  if (Field.getType()->isRecordType()) {
    copyRecord(cast<RecordStorageLocation>(*SrcFieldLoc),
               cast<RecordStorageLocation>(*DstFieldLoc), Env);
  } else if (Field.getType()->isReferenceType()) {
    Dst.setChild(Field, SrcFieldLoc);
  } else {
    if (Value *Val = Env.getValue(*SrcFieldLoc))
      Env.setValue(*DstFieldLoc, *Val);
    else
      Env.clearValue(*DstFieldLoc);
  }
}

static void copySyntheticField(QualType FieldType, StorageLocation &SrcFieldLoc,
                               StorageLocation &DstFieldLoc, Environment &Env) {
  if (FieldType->isRecordType()) {
    copyRecord(cast<RecordStorageLocation>(SrcFieldLoc),
               cast<RecordStorageLocation>(DstFieldLoc), Env);
  } else {
    if (Value *Val = Env.getValue(SrcFieldLoc))
      Env.setValue(DstFieldLoc, *Val);
    else
      Env.clearValue(DstFieldLoc);
  }
}

void copyRecord(RecordStorageLocation &Src, RecordStorageLocation &Dst,
                Environment &Env, const QualType TypeToCopy) {
  auto SrcType = Src.getType().getCanonicalType().getUnqualifiedType();
  auto DstType = Dst.getType().getCanonicalType().getUnqualifiedType();

  auto SrcDecl = SrcType->getAsCXXRecordDecl();
  auto DstDecl = DstType->getAsCXXRecordDecl();

  const CXXRecordDecl *DeclToCopy =
      TypeToCopy.isNull() ? nullptr : TypeToCopy->getAsCXXRecordDecl();

  [[maybe_unused]] bool CompatibleTypes =
      SrcType == DstType ||
      (SrcDecl != nullptr && DstDecl != nullptr &&
       (SrcDecl->isDerivedFrom(DstDecl) || DstDecl->isDerivedFrom(SrcDecl) ||
        (DeclToCopy != nullptr && SrcDecl->isDerivedFrom(DeclToCopy) &&
         DstDecl->isDerivedFrom(DeclToCopy))));

  LLVM_DEBUG({
    if (!CompatibleTypes) {
      llvm::dbgs() << "Source type " << Src.getType() << "\n";
      llvm::dbgs() << "Destination type " << Dst.getType() << "\n";
    }
  });
  assert(CompatibleTypes);

  if (SrcType == DstType || (SrcDecl != nullptr && DstDecl != nullptr &&
                             SrcDecl->isDerivedFrom(DstDecl))) {
    // Dst may have children modeled from other derived types than SrcType, e.g.
    // after casts of Dst to other types derived from DstType. Only copy the
    // children and synthetic fields present in both Dst and SrcType.
    const FieldSet FieldsInSrcType =
        Env.getDataflowAnalysisContext().getModeledFields(SrcType);
    for (auto [Field, DstFieldLoc] : Dst.children())
      if (const auto *FieldAsFieldDecl = dyn_cast<FieldDecl>(Field);
          FieldAsFieldDecl && FieldsInSrcType.contains(FieldAsFieldDecl))
        copyField(*Field, Src.getChild(*Field), DstFieldLoc, Dst, Env);
    const llvm::StringMap<QualType> SyntheticFieldsForSrcType =
        Env.getDataflowAnalysisContext().getSyntheticFields(SrcType);
    for (const auto &[Name, DstFieldLoc] : Dst.synthetic_fields())
      if (SyntheticFieldsForSrcType.contains(Name))
        copySyntheticField(DstFieldLoc->getType(), Src.getSyntheticField(Name),
                           *DstFieldLoc, Env);
  } else if (SrcDecl != nullptr && DstDecl != nullptr &&
             DstDecl->isDerivedFrom(SrcDecl)) {
    // Src may have children modeled from other derived types than DstType, e.g.
    // after other casts of Src to those types (likely in different branches,
    // but without flow-condition-dependent field modeling). Only copy the
    // children and synthetic fields of Src that are present in DstType.
    const FieldSet FieldsInDstType =
        Env.getDataflowAnalysisContext().getModeledFields(DstType);
    for (auto [Field, SrcFieldLoc] : Src.children()) {
      if (const auto *FieldAsFieldDecl = dyn_cast<FieldDecl>(Field);
          FieldAsFieldDecl && FieldsInDstType.contains(FieldAsFieldDecl))
        copyField(*Field, SrcFieldLoc, Dst.getChild(*Field), Dst, Env);
    }
    const llvm::StringMap<QualType> SyntheticFieldsForDstType =
        Env.getDataflowAnalysisContext().getSyntheticFields(DstType);
    for (const auto &[Name, SrcFieldLoc] : Src.synthetic_fields()) {
      if (SyntheticFieldsForDstType.contains(Name))
        copySyntheticField(SrcFieldLoc->getType(), *SrcFieldLoc,
                           Dst.getSyntheticField(Name), Env);
    }
  } else {
    for (const FieldDecl *Field :
         Env.getDataflowAnalysisContext().getModeledFields(TypeToCopy)) {
      copyField(*Field, Src.getChild(*Field), Dst.getChild(*Field), Dst, Env);
    }
    for (const auto &[SyntheticFieldName, SyntheticFieldType] :
         Env.getDataflowAnalysisContext().getSyntheticFields(TypeToCopy)) {
      copySyntheticField(SyntheticFieldType,
                         Src.getSyntheticField(SyntheticFieldName),
                         Dst.getSyntheticField(SyntheticFieldName), Env);
    }
  }
}

bool recordsEqual(const RecordStorageLocation &Loc1, const Environment &Env1,
                  const RecordStorageLocation &Loc2, const Environment &Env2) {
  LLVM_DEBUG({
    if (Loc2.getType().getCanonicalType().getUnqualifiedType() !=
        Loc1.getType().getCanonicalType().getUnqualifiedType()) {
      llvm::dbgs() << "Loc1 type " << Loc1.getType() << "\n";
      llvm::dbgs() << "Loc2 type " << Loc2.getType() << "\n";
    }
  });
  assert(Loc2.getType().getCanonicalType().getUnqualifiedType() ==
         Loc1.getType().getCanonicalType().getUnqualifiedType());

  for (auto [Field, FieldLoc1] : Loc1.children()) {
    StorageLocation *FieldLoc2 = Loc2.getChild(*Field);

    assert(Field->getType()->isReferenceType() ||
           (FieldLoc1 != nullptr && FieldLoc2 != nullptr));

    if (Field->getType()->isRecordType()) {
      if (!recordsEqual(cast<RecordStorageLocation>(*FieldLoc1), Env1,
                        cast<RecordStorageLocation>(*FieldLoc2), Env2))
        return false;
    } else if (Field->getType()->isReferenceType()) {
      if (FieldLoc1 != FieldLoc2)
        return false;
    } else if (Env1.getValue(*FieldLoc1) != Env2.getValue(*FieldLoc2)) {
      return false;
    }
  }

  for (const auto &[Name, SynthFieldLoc1] : Loc1.synthetic_fields()) {
    if (SynthFieldLoc1->getType()->isRecordType()) {
      if (!recordsEqual(
              *cast<RecordStorageLocation>(SynthFieldLoc1), Env1,
              cast<RecordStorageLocation>(Loc2.getSyntheticField(Name)), Env2))
        return false;
    } else if (Env1.getValue(*SynthFieldLoc1) !=
               Env2.getValue(Loc2.getSyntheticField(Name))) {
      return false;
    }
  }

  return true;
}

} // namespace clang::dataflow