Method getByteAccessInfo

ir/instr.cpp:2364–2425

}

MemInstr::ByteAccessInfo FnCall::getByteAccessInfo() const {
  if (attrs.has(AllocKind::Uninitialized) || attrs.has(AllocKind::Free))
    return {};

  bool has_ptr_args = any_of(args.begin(), args.end(),
    [](const auto &pair) {
      auto &[val, attrs] = pair;
      return hasPtr(val->getType()) &&
             !attrs.has(ParamAttrs::ByVal) &&
             !attrs.has(ParamAttrs::NoCapture);
    });

  // calloc style
  if (attrs.has(AllocKind::Zeroed)) {
    auto info = ByteAccessInfo::intOnly(1);
    auto [alloc, align] = getMaxAllocSize();
    if (alloc)
      info.byteSize = gcd(alloc, align);
    info.observesAddresses = has_ptr_args;
    return info;
  }

  // If bytesize is zero, this call does not participate in byte encoding.
  uint64_t bytesize = 0;

#define UPDATE(attr)                                                   \
  do {                                                                 \
    uint64_t sz = 0;                                                   \
    if (attr.has(decay<decltype(attr)>::type::Dereferenceable))        \
      sz = attr.derefBytes;                                            \
    if (attr.has(decay<decltype(attr)>::type::DereferenceableOrNull))  \
      sz = gcd(sz, attr.derefOrNullBytes);                             \
    if (sz) {                                                          \
      sz = gcd(sz, retattr.align ? retattr.align : 1);                 \
      bytesize = bytesize ? gcd(bytesize, sz) : sz;                    \
    }                                                                  \
  } while (0)

  auto &retattr = getAttributes();
  UPDATE(retattr);

  for (auto &[arg, attrs] : args) {
    if (!arg->getType().isPtrType())
      continue;

    UPDATE(attrs);
    // Pointer arguments without dereferenceable attr don't contribute to the
    // byte size.
    // call f(* dereferenceable(n) align m %p, * %q) is equivalent to a dummy
    // load followed by a function call:
    //   load i<8*n> %p, align m
    //   call f(* %p, * %q)
    // f(%p, %q) does not contribute to the bytesize. After bytesize is fixed,
    // function calls update a memory with the granularity.
  }
#undef UPDATE

  ByteAccessInfo info;