/* { dg-additional-options "-std=c++20" } */

/* bit_cast and memcpy  */

#include <bit>
#include <cstring>

#include "target-flex-common.h"

struct S0
{
  int _v0;
  char _v1;
  long long _v2;
};

struct S1
{
  int _v0;
  char _v1;
  long long _v2;
};

bool test_bit_cast(int arg)
{
  bool ok;
  S1 s1_out;
  #pragma omp target map(from: ok, s1_out) map(to: arg)
    {
      bool inner_ok = true;
      {
	long long v = static_cast<long long>(arg + 42ll);
	S0 s = {arg, 'a', v};
	VERIFY (std::bit_cast<S1>(s)._v0 == arg);
	VERIFY (std::bit_cast<S1>(s)._v1 == 'a');
	VERIFY (std::bit_cast<S1>(s)._v2 == v);
	s1_out = std::bit_cast<S1>(s);
      }
      end:
      ok = inner_ok;
    }
  if (!ok)
    return false;
  long long v = static_cast<long long>(arg + 42ll);
  VERIFY_NON_TARGET (std::bit_cast<S0>(s1_out)._v0 == arg);
  VERIFY_NON_TARGET (std::bit_cast<S0>(s1_out)._v1 == 'a');
  VERIFY_NON_TARGET (std::bit_cast<S0>(s1_out)._v2 == v);
  return true;
}


struct OutStruct
{
  std::size_t _id;
  void *_next;
};

struct Extendable1
{
  std::size_t _id;
  void *_next;
  int _v;
};

struct Extendable2
{
  std::size_t _id;
  void *_next;
  char _str[256];
};

struct Extendable3
{
  std::size_t _id;
  void *_next;
  const int *_nums;
  std::size_t _size;
};

struct ExtendableUnknown
{
  std::size_t _id;
  void *_next;
};

template<typename To, std::size_t Id>
To *get_extendable(void *p)
{
  while (p != nullptr)
    {
      OutStruct out;
      std::memcpy(&out, p, sizeof(OutStruct));
      if (out._id == Id)
	return static_cast<To *>(p);
      p = out._next;
    }
  return nullptr;
}

bool test_memcpy(int arg, const int *nums, std::size_t nums_size)
{
  bool ok;
  Extendable2 e2_out;
  #pragma omp target map(from: ok, e2_out) map(to: arg, nums[:nums_size], nums_size)
    {
      bool inner_ok = true;
      {
	Extendable3 e3 = {3u, nullptr, nums, nums_size};
	ExtendableUnknown u1 = {100u, &e3};
	Extendable2 e2 = {2u, &u1, {'H', 'e', 'l', 'l', 'o', '!', '\000'}};
	ExtendableUnknown u2 = {101u, &e2};
	ExtendableUnknown u3 = {102u, &u2};
	ExtendableUnknown u4 = {142u, &u3};
	Extendable1 e1 = {1u, &u4, arg};

	void *p = &e1;
	while (p != nullptr)
	  {
	    /* You can always cast a pointer to a struct to a pointer to
	       the type of it's first member.  */
	    switch (*static_cast<std::size_t *>(p))
	      {
		case 1:
		  {
		    Extendable1 *e1_p = static_cast<Extendable1 *>(p);
		    p = e1_p->_next;
		    VERIFY (e1_p->_v == arg);
		    break;
		  }
		case 2:
		  {
		    Extendable2 *e2_p = static_cast<Extendable2 *>(p);
		    p = e2_p->_next;
		    VERIFY (std::strcmp(e2_p->_str, "Hello!") == 0);
		    break;
		  }
		case 3:
		  {
		    Extendable3 *e3_p = static_cast<Extendable3 *>(p);
		    p = e3_p->_next;
		    VERIFY (nums == e3_p->_nums);
		    VERIFY (nums_size == e3_p->_size);
		    break;
		  }
		default:
		  {
		    /* Casting to a pointer to OutStruct invokes undefined
		       behavior though, memcpy is required to extract the _next
		       member.  */
		    OutStruct out;
		    std::memcpy(&out, p, sizeof(OutStruct));
		    p = out._next;
		  }
	      }
	  }
	Extendable2 *e2_p = get_extendable<Extendable2, 2u>(&e1);
	VERIFY (e2_p != nullptr);
	e2_out = *e2_p;
      }
      end:
      ok = inner_ok;
    }
  if (!ok)
    return false;
  VERIFY_NON_TARGET (e2_out._id == 2u);
  VERIFY_NON_TARGET (std::strcmp(e2_out._str, "Hello!") == 0);
  return true;
}

int main()
{
  volatile int arg = 42;
  int arr[8] = {0, 1, 2, 3, 4, 5, 6, 7};
  return test_bit_cast(arg)
	 && test_memcpy(arg, arr, 8) ? 0 : 1;
}