Method getPackedAlignment

source/opt/struct_packing_pass.cpp:168–224

}

uint32_t StructPackingPass::getPackedAlignment(
    const analysis::Type& type) const {
  switch (type.kind()) {
    case analysis::Type::kArray: {
      // Get alignment of base type and round up to minimum alignment
      const uint32_t minAlignment = isPackingVec4Padded(packingRules_) ? 16 : 1;
      return std::max<uint32_t>(
          minAlignment, getPackedAlignment(*type.AsArray()->element_type()));
    }
    case analysis::Type::kStruct: {
      // Rule 9. Struct alignment is maximum alignmnet of its members
      uint32_t alignment = 1;

      for (const analysis::Type* elementType :
           type.AsStruct()->element_types()) {
        alignment =
            std::max<uint32_t>(alignment, getPackedAlignment(*elementType));
      }

      if (isPackingVec4Padded(packingRules_))
        alignment = std::max<uint32_t>(alignment, 16u);

      return alignment;
    }
    default: {
      const uint32_t baseAlignment = getPackedBaseSize(type);

      // Scalar block layout always uses alignment for the most basic component
      if (isPackingScalar(packingRules_)) return baseAlignment;

      if (const analysis::Matrix* matrixType = type.AsMatrix()) {
        // Rule 5/7
        if (isPackingVec4Padded(packingRules_) ||
            matrixType->element_count() == 3)
          return baseAlignment * 4;
        else
          return baseAlignment * matrixType->element_count();
      } else if (const analysis::Vector* vectorType = type.AsVector()) {
        // Rule 1
        if (vectorType->element_count() == 1) return baseAlignment;

        // Rule 2
        if (vectorType->element_count() == 2 ||
            vectorType->element_count() == 4)
          return baseAlignment * vectorType->element_count();

        // Rule 3
        if (vectorType->element_count() == 3) return baseAlignment * 4;
      } else {
        // Rule 1
        return baseAlignment;
      }
    }
  }
  assert(0 && "Unrecognized type to get packed alignment");
  return 0;
}