Function MakeMisalignedDecimalOutput

cpp/src/gandiva/tests/decimal_alignment_test.cc:159–203

Create a misaligned output buffer for decimal128

// Create a misaligned output buffer for decimal128
std::shared_ptr<arrow::ArrayData> MakeMisalignedDecimalOutput(
    const std::shared_ptr<arrow::Decimal128Type>& type, int64_t num_records,
    int alignment_offset) {
  // Allocate data buffer with extra space for misalignment
  int64_t data_size = num_records * 16;  // 16 bytes per Decimal128
  int64_t buffer_size = data_size + 16;  // Extra space for offset

  std::shared_ptr<arrow::Buffer> buffer;
  ARROW_EXPECT_OK(arrow::AllocateBuffer(buffer_size).Value(&buffer));

  uint8_t* raw_data = const_cast<uint8_t*>(buffer->data());
  uintptr_t addr = reinterpret_cast<uintptr_t>(raw_data);

  // Find offset to get to 8-byte aligned but not 16-byte aligned address
  int offset_to_8 = (8 - (addr % 8)) % 8;
  int current_16_alignment = (addr + offset_to_8) % 16;

  int final_offset;
  if (alignment_offset == 8) {
    if (current_16_alignment == 0) {
      final_offset = offset_to_8 + 8;
    } else {
      final_offset = offset_to_8;
    }
  } else {
    final_offset = (16 - (addr % 16)) % 16;
  }

  // Verify alignment
  uintptr_t data_addr = reinterpret_cast<uintptr_t>(raw_data + final_offset);
  EXPECT_EQ(data_addr % 8, 0) << "Data should be 8-byte aligned";
  if (alignment_offset == 8) {
    EXPECT_NE(data_addr % 16, 0) << "Data should NOT be 16-byte aligned";
  }

  auto sliced_buffer = arrow::SliceBuffer(buffer, final_offset, data_size);

  // Create validity buffer
  int64_t bitmap_size = (num_records + 7) / 8;
  std::shared_ptr<arrow::Buffer> validity_buffer;
  ARROW_EXPECT_OK(arrow::AllocateBuffer(bitmap_size).Value(&validity_buffer));
  memset(const_cast<uint8_t*>(validity_buffer->data()), 0xFF, validity_buffer->size());

  return arrow::ArrayData::Make(type, num_records, {validity_buffer, sliced_buffer});
}

// Test that decimal STORES work correctly with 8-byte aligned (but not 16-byte aligned)
// output