Function omDoCheckTrackAddr

omalloc/omDebugTrack.c:469–572

static omError_t omDoCheckTrackAddr(omTrackAddr d_addr, void* addr, void* bin_size, omTrackFlags_t flags, char level,
                                    omError_t report, OM_FLR_DECL)
{
  if (flags & OM_FUSED)
    omAddrCheckReturnError(d_addr->next != ((void*) -1), omError_FreedAddrOrMemoryCorrupted);
  else
    omAddrCheckReturnError(d_addr->next != NULL && omCheckPtr(d_addr->next, omError_MaxError, OM_FLR_VAL),
                           omError_FreedAddrOrMemoryCorrupted);
  omAddrCheckReturnCorrupted(omCheckFlags(d_addr->flags));

  omAddrCheckReturnError(level > 1 && (flags & OM_FUSED) && omIsInKeptAddrList(d_addr), omError_FreedAddr);
  omAddrCheckReturnError((d_addr->flags & OM_FUSED) ^ (flags & OM_FUSED), omError_FreedAddrOrMemoryCorrupted);

  if (flags & OM_FBINADDR && flags & OM_FSIZE)
    omAddrCheckReturnError(omTrackAddr_2_OutSize(d_addr) != (size_t) bin_size, omError_WrongSize);

  if (d_addr->track > 2)
  {
    if (d_addr->flags & OM_FBIN)
    {
      omAddrCheckReturnCorrupted(!omIsKnownTopBin((omBin) d_addr->bin_size, 1));
    }
    else
    {
      omAssume(d_addr->flags & OM_FSIZE);

      omAddrCheckReturnCorrupted(!OM_IS_ALIGNED(d_addr->bin_size));
      omAddrCheckReturnCorrupted((size_t) d_addr->bin_size >
                                 omSizeOfBinAddr(d_addr)
                                 - omTrackAddr_2_SizeOfTrackAddrHeader(d_addr)
                                 - OM_MIN_SIZEOF_BACK_PATTERN);
      /* Hmm .. here I'd love to have a stricter bound */
      omAddrCheckReturnCorrupted((size_t) d_addr->bin_size < SIZEOF_OM_ALIGNMENT);
    }

    omAddrCheckReturnError((flags & OM_FBINADDR) && !((d_addr->flags & OM_FBIN) || ((size_t) d_addr->bin_size <= OM_MAX_BLOCK_SIZE)), omError_NotBinAddr);

    if (flags & OM_FBIN)
    {
      if (d_addr->flags & OM_FBIN)
        omAddrCheckReturnError(((omBin) d_addr->bin_size)->sizeW != ((omBin) bin_size)->sizeW, omError_WrongBin);
      else
        omAddrCheckReturnError((((omBin) bin_size)->sizeW << LOG_SIZEOF_LONG) != OM_ALIGN_SIZE((size_t) d_addr->bin_size), omError_WrongBin);
    }
    else if (flags & OM_FSIZE)
    {
      if (d_addr->flags & OM_FBIN)
      {
        omAddrCheckReturnError((((omBin) d_addr->bin_size)->sizeW << LOG_SIZEOF_LONG) < ((size_t) bin_size), omError_WrongSize);
      }
      else
      {
        omAddrCheckReturnError((size_t) d_addr->bin_size < (size_t) bin_size, omError_WrongSize);
      }
    }

    omAddrCheckReturnError(omCheckPattern(omTrackAddr_2_FrontPattern(d_addr), OM_FRONT_PATTERN,omTrackAddr_2_SizeOfFrontPattern(d_addr)),omError_FrontPattern);
    omAddrCheckReturnError(omCheckPattern(omTrackAddr_2_BackPattern(d_addr), OM_BACK_PATTERN,omTrackAddr_2_SizeOfBackPattern(d_addr)),omError_BackPattern);