/* Test program for read_[type]_unaligned.

   Copyright (C) 2020, Red Hat Inc.

   This file is part of elfutils.

   This file is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   elfutils is distributed in the hope that it will be useful, but

   WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include <assert.h>

#include <endian.h>

#include <inttypes.h>

#include <stdbool.h>

#include <stdint.h>

#include <stdio.h>

#include "../libdw/libdwP.h"

#include "../libdw/memory-access.h"

union u8

{

  uint8_t v;

  unsigned char c[1];

};

union s8

{

  int8_t v;

  unsigned char c[1];

};

union u16

{

  uint16_t v;

  unsigned char c[2];

};

union s16

{

  int16_t v;

  unsigned char c[2];

};

union u24

{

  uint32_t v:24;

  unsigned char c[3];

} __attribute__((packed));

union u32

{

  uint32_t v;

  unsigned char c[4];

};

union s32

{

  int32_t v;

  unsigned char c[4];

};

union u64

{

  uint64_t v;

  unsigned char c[8];

};

union s64

{

  uint64_t v;

  unsigned char c[8];

};

uint8_t u8_nums[] =

  {

   0,

   1,

   UINT8_MAX / 2 - 1,

   UINT8_MAX / 2,

   UINT8_MAX / 2 + 1,

   UINT8_MAX,

   UINT8_MAX -1

  };

int8_t s8_nums[] =

  {

   INT8_MIN,

   INT8_MIN + 1,

   -1,

   0,

   1,

   INT8_MAX,

   INT8_MAX - 1

  };

uint16_t u16_nums[] =

  {

   0,

   1,

   UINT16_MAX / 2 - 1,

   UINT16_MAX / 2,

   UINT16_MAX / 2 + 1,

   UINT16_MAX,

   UINT16_MAX -1

  };

int16_t s16_nums[] =

  {

   INT16_MIN,

   INT16_MIN + 1,

   -1,

   0,

   1,

   INT16_MAX,

   INT16_MAX - 1

  };

#define UINT24_MAX 0xffffff

uint32_t u24_nums[] =

  {

   0,

   1,

   UINT24_MAX / 2 - 1,

   UINT24_MAX / 2,

   UINT24_MAX / 2 + 1,

   UINT24_MAX,

   UINT24_MAX -1

  };

uint32_t u32_nums[] =

  {

   0,

   1,

   UINT32_MAX / 2 - 1,

   UINT32_MAX / 2,

   UINT32_MAX / 2 + 1,

   UINT32_MAX,

   UINT32_MAX -1

  };

int32_t s32_nums[] =

  {

   INT32_MIN,

   INT32_MIN + 1,

   -1,

   0,

   1,

   INT32_MAX,

   INT32_MAX - 1

  };

uint64_t u64_nums[] =

  {

   0,

   1,

   UINT64_MAX / 2 - 1,

   UINT64_MAX / 2,

   UINT64_MAX / 2 + 1,

   UINT64_MAX,

   UINT64_MAX -1

  };

int64_t s64_nums[] =

  {

   INT64_MIN,

   INT64_MIN + 1,

   -1,

   0,

   1,

   INT64_MAX,

   INT64_MAX - 1

  };

static unsigned char le_mem[] =

  {

    /* u8 */

    0x00,

    0x01,

    0x7e,

    0x7f,

    0x80,

    0xff,

    0xfe,

    /* s8 */

    0x80,

    0x81,

    0xff,

    0x00,

    0x01,

    0x7f,

    0x7e,

    /* u16 */

    0x00, 0x00,

    0x01, 0x00,

    0xfe, 0x7f,

    0xff, 0x7f,

    0x00, 0x80,

    0xff, 0xff,

    0xfe, 0xff,

    /* s16 */

    0x00, 0x80,

    0x01, 0x80,

    0xff, 0xff,

    0x00, 0x00,

    0x01, 0x00,

    0xff, 0x7f,

    0xfe, 0x7f,

    /* u24 */

    0x00, 0x00, 0x00,

    0x01, 0x00, 0x00,

    0xfe, 0xff, 0x7f,

    0xff, 0xff, 0x7f,

    0x00, 0x00, 0x80,

    0xff, 0xff, 0xff,

    0xfe, 0xff, 0xff,

    /* u32 */

    0x00, 0x00, 0x00, 0x00,

    0x01, 0x00, 0x00, 0x00,

    0xfe, 0xff, 0xff, 0x7f,

    0xff, 0xff, 0xff, 0x7f,

    0x00, 0x00, 0x00, 0x80,

    0xff, 0xff, 0xff, 0xff,

    0xfe, 0xff, 0xff, 0xff,

    /* s32 */

    0x00, 0x00, 0x00, 0x80,

    0x01, 0x00, 0x00, 0x80,

    0xff, 0xff, 0xff, 0xff,

    0x00, 0x00, 0x00, 0x00,

    0x01, 0x00, 0x00, 0x00,

    0xff, 0xff, 0xff, 0x7f,

    0xfe, 0xff, 0xff, 0x7f,

    /* u64 */

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f,

    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f,

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,

    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

    0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

    /* s64 */

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,

    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,

    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f,

    0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f,

  };

static unsigned char be_mem[] =

  {

    /* u8 */

    0x00,

    0x01,

    0x7e,

    0x7f,

    0x80,

    0xff,

    0xfe,

    /* s8 */

    0x80,

    0x81,

    0xff,

    0x00,

    0x01,

    0x7f,

    0x7e,

    /* u16 */

    0x00, 0x00,

    0x00, 0x01,

    0x7f, 0xfe,

    0x7f, 0xff,

    0x80, 0x00,

    0xff, 0xff,

    0xff, 0xfe,

    /* s16 */

    0x80, 0x00,

    0x80, 0x01,

    0xff, 0xff,

    0x00, 0x00,

    0x00, 0x01,

    0x7f, 0xff,

    0x7f, 0xfe,

    /* u24 */

    0x00, 0x00, 0x00,

    0x00, 0x00, 0x01,

    0x7f, 0xff, 0xfe,

    0x7f, 0xff, 0xff,

    0x80, 0x00, 0x00,

    0xff, 0xff, 0xff,

    0xff, 0xff, 0xfe,

    /* u32 */

    0x00, 0x00, 0x00, 0x00,

    0x00, 0x00, 0x00, 0x01,

    0x7f, 0xff, 0xff, 0xfe,

    0x7f, 0xff, 0xff, 0xff,

    0x80, 0x00, 0x00, 0x00,

    0xff, 0xff, 0xff, 0xff,

    0xff, 0xff, 0xff, 0xfe,

    /* s32 */

    0x80, 0x00, 0x00, 0x00,

    0x80, 0x00, 0x00, 0x01,

    0xff, 0xff, 0xff, 0xff,

    0x00, 0x00, 0x00, 0x00,

    0x00, 0x00, 0x00, 0x01,

    0x7f, 0xff, 0xff, 0xff,

    0x7f, 0xff, 0xff, 0xfe,

    /* u64 */

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,

    0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,

    0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,

    /* s64 */

    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,

    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,

    0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

    0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,

  };

int

main (int argc, char **argv __attribute__((unused)))

{

  /* No arguments means check, otherwise Write out the memory array.  */

  bool write = false;

  if (argc > 1)

    write = true;

  bool is_le = (BYTE_ORDER == LITTLE_ENDIAN);

  if (write)

    {

      if (is_le)

	printf ("static unsigned char le_mem[] =\n");

      else

	printf ("static unsigned char be_mem[] =\n");

      printf ("  {\n");

    }

  Dwarf dbg_le = { .other_byte_order = !is_le };

  Dwarf dbg_be = { .other_byte_order = is_le };

  unsigned char *p_le = le_mem;

  unsigned char *p_be = be_mem;

  union u8 u8;

  if (write)

    printf ("    /* u8 */\n");

  for (size_t i = 0; i < sizeof (u8_nums) / sizeof (u8); i++)

    {

      if (write)

	{

	  u8.v = u8_nums[i];

	  printf ("    0x%02" PRIx8 ",\n", u8.c[0]);

	}

      else

	{

	  uint8_t v = *p_le++;

	  assert (v == u8_nums[i]);

	  v = *p_be++;

	  assert (v == u8_nums[i]);

	}

    }

  union s8 s8;

  if (write)

    printf ("    /* s8 */\n");

  for (size_t i = 0; i < sizeof (s8_nums) / sizeof (s8); i++)

    {

      if (write)

	{

	  s8.v = s8_nums[i];

	  printf ("    0x%02" PRIx8 ",\n", s8.c[0]);

	}

      else

	{

	  int8_t v = *p_le++;

	  assert (v == s8_nums[i]);

	  v = *p_be++;

	  assert (v == s8_nums[i]);

	}

    }

  union u16 u16;

  if (write)

    printf ("    /* u16 */\n");

  for (size_t i = 0; i < sizeof (u16_nums) / sizeof (u16); i++)

    {

      if (write)

	{

	  u16.v = u16_nums[i];

	  printf ("    0x%02" PRIx8 ", ", u16.c[0]);

	  printf ("0x%02" PRIx8 ",\n", u16.c[1]);

	}

      else

	{

	  uint16_t v = read_2ubyte_unaligned_inc (&dbg_le, p_le);

	  assert (v == u16_nums[i]);

	  v = read_2ubyte_unaligned_inc (&dbg_be, p_be);

	  assert (v == u16_nums[i]);

	}

    }

  union s16 s16;

  if (write)

    printf ("    /* s16 */\n");

  for (size_t i = 0; i < sizeof (s16_nums) / sizeof (s16); i++)

    {

      if (write)

	{

	  s16.v = s16_nums[i];

	  printf ("    0x%02" PRIx8 ", ", s16.c[0]);

	  printf ("0x%02" PRIx8 ",\n", s16.c[1]);

	}

      else

	{

	  int16_t v = read_2sbyte_unaligned_inc (&dbg_le, p_le);

	  assert (v == s16_nums[i]);

	  v = read_2sbyte_unaligned_inc (&dbg_be, p_be);

	  assert (v == s16_nums[i]);

	}

    }

  union u24 u24;

  if (write)

    printf ("    /* u24 */\n");

  for (size_t i = 0; i < sizeof (u24_nums) / sizeof (uint32_t); i++)

    {

      if (write)

	{

	  u24.v = u24_nums[i];

	  printf ("    0x%02" PRIx8 ", ", u24.c[0]);

	  printf ("0x%02" PRIx8 ", ", u24.c[1]);

	  printf ("0x%02" PRIx8 ",\n", u24.c[2]);

	}

      else

	{

	  uint32_t v = read_3ubyte_unaligned_inc (&dbg_le, p_le);

	  assert (v == u24_nums[i]);

	  v = read_3ubyte_unaligned_inc (&dbg_be, p_be);

	  assert (v == u24_nums[i]);

	}

    }

  union u32 u32;

  if (write)

    printf ("    /* u32 */\n");

  for (size_t i = 0; i < sizeof (u32_nums) / sizeof (u32); i++)

    {

      if (write)

	{

	  u32.v = u32_nums[i];

	  printf ("    0x%02" PRIx8 ", ", u32.c[0]);

	  printf ("0x%02" PRIx8 ", ", u32.c[1]);

	  printf ("0x%02" PRIx8 ", ", u32.c[2]);

	  printf ("0x%02" PRIx8 ",\n", u32.c[3]);

	}

      else

	{

	  uint32_t v = read_4ubyte_unaligned_inc (&dbg_le, p_le);

	  assert (v == u32_nums[i]);

	  v = read_4ubyte_unaligned_inc (&dbg_be, p_be);

	  assert (v == u32_nums[i]);

	}

    }

  union s32 s32;

  if (write)

    printf ("    /* s32 */\n");

  for (size_t i = 0; i < sizeof (s32_nums) / sizeof (s32); i++)

    {

      if (write)

	{

	  s32.v = s32_nums[i];

	  printf ("    0x%02" PRIx8 ", ", s32.c[0]);

	  printf ("0x%02" PRIx8 ", ", s32.c[1]);

	  printf ("0x%02" PRIx8 ", ", s32.c[2]);

	  printf ("0x%02" PRIx8 ",\n", s32.c[3]);

	}

      else

	{

	  int32_t v = read_4sbyte_unaligned_inc (&dbg_le, p_le);

	  assert (v == s32_nums[i]);

	  v = read_4sbyte_unaligned_inc (&dbg_be, p_be);

	  assert (v == s32_nums[i]);

	}

    }

  union u64 u64;

  if (write)

    printf ("    /* u64 */\n");

  for (size_t i = 0; i < sizeof (u64_nums) / sizeof (u64); i++)

    {

      if (write)

	{

	  u64.v = u64_nums[i];

	  printf ("    0x%02" PRIx8 ", ", u64.c[0]);

	  printf ("0x%02" PRIx8 ", ", u64.c[1]);

	  printf ("0x%02" PRIx8 ", ", u64.c[2]);

	  printf ("0x%02" PRIx8 ", ", u64.c[3]);

	  printf ("0x%02" PRIx8 ", ", u64.c[4]);

	  printf ("0x%02" PRIx8 ", ", u64.c[5]);

	  printf ("0x%02" PRIx8 ", ", u64.c[6]);

	  printf ("0x%02" PRIx8 ",\n", u64.c[7]);

	}

      else

	{

	  uint64_t v = read_8ubyte_unaligned_inc (&dbg_le, p_le);

	  assert (v == u64_nums[i]);

	  v = read_8ubyte_unaligned_inc (&dbg_be, p_be);

	  assert (v == u64_nums[i]);

	}

    }

  union s64 s64;

  if (write)

    printf ("    /* s64 */\n");

  for (size_t i = 0; i < sizeof (s64_nums) / sizeof (s64); i++)

    {

      if (write)

	{

	  s64.v = s64_nums[i];

	  printf ("    0x%02" PRIx8 ", ", s64.c[0]);

	  printf ("0x%02" PRIx8 ", ", s64.c[1]);

	  printf ("0x%02" PRIx8 ", ", s64.c[2]);

	  printf ("0x%02" PRIx8 ", ", s64.c[3]);

	  printf ("0x%02" PRIx8 ", ", s64.c[4]);

	  printf ("0x%02" PRIx8 ", ", s64.c[5]);

	  printf ("0x%02" PRIx8 ", ", s64.c[6]);

	  printf ("0x%02" PRIx8 ",\n", s64.c[7]);

	}

      else

	{

	  int64_t v = read_8sbyte_unaligned_inc (&dbg_le, p_le);

	  assert (v == s64_nums[i]);

	  v = read_8sbyte_unaligned_inc (&dbg_be, p_be);

	  assert (v == s64_nums[i]);

	}

    }

  if (write)

    printf ("  };\n");

  else

    {

      assert (p_le == le_mem + sizeof (le_mem));

      assert (p_be == be_mem + sizeof (be_mem));

    }

  return 0;

}