/* { dg-do compile { target x86_64-*-* } } */

#include "libgccjit++.h"

#include "harness.h"

/**********************************************************************
 Support fns for creating code.
 **********************************************************************/

/* Make a "void FUNC_NAME (void)" function with a single block, returning
   that block.  */

static gccjit::block
make_single_block_func (gccjit::context ctxt, const char *func_name)
{
  gccjit::type void_type = ctxt.get_type (GCC_JIT_TYPE_VOID);
  std::vector<gccjit::param> params;
  gccjit::function func
    = ctxt.new_function (GCC_JIT_FUNCTION_EXPORTED,
			 void_type,
			 func_name, params, 0);
  return func.new_block ("initial");
}

/**********************************************************************
 Support fns for verifying code.
 **********************************************************************/

typedef void (*void_void_fn) (void);

static void_void_fn
get_test_fn (gcc_jit_result *result, const char *func_name)
{
  return (void_void_fn)gcc_jit_result_get_code (result, func_name);
}

/**********************************************************************
 test_i386_basic_asm_1: simple example of asm
 **********************************************************************/

/* Create the equivalent of:

     int src;
     int dst;

     void test_i386_basic_asm_1 (void)
     {
       // Quote from here in docs/cp/topics/asm.rst: example 1: C
       asm ("mov %1, %0\n\t"
            "add $1, %0"
            : "=r" (dst)
            : "r" (src));
       // Quote up to here in docs/cp/topics/asm.rst: example 1: C
     }

     i.e. copy src to dst and add 1 to dst.  */

static void
create_test_i386_basic_asm_1 (gcc_jit_context *c_ctxt)
{
  gccjit::context ctxt (c_ctxt);
  gccjit::type int_type = ctxt.get_type (GCC_JIT_TYPE_INT);
  gccjit::lvalue dst
    = ctxt.new_global (GCC_JIT_GLOBAL_EXPORTED, int_type, "dst");
  gccjit::lvalue src
    = ctxt.new_global (GCC_JIT_GLOBAL_EXPORTED, int_type, "src");

  gccjit::block block
    = make_single_block_func (ctxt, "test_i386_basic_asm_1");

  gccjit::extended_asm ext_asm =
  /* Quote from here in docs/cp/topics/asm.rst: example 1: jit.  */
    block.add_extended_asm ("mov %1, %0\n\t"
                            "add $1, %0")
    .add_output_operand ("=r", dst)
    .add_input_operand ("r", src);
  /* Quote up to here in docs/cp/topics/asm.rst: example 1: jit.  */

  std::string desc = ext_asm.get_debug_string ();
  CHECK_STRING_VALUE
    (desc.c_str (),
     "asm (\"mov %1, %0\\n\\tadd $1, %0\" : \"=r\" (dst) : \"r\" (src) : )");

  block.end_with_return ();
}

static void
verify_code_1 (gcc_jit_context *ctxt, gcc_jit_result *result)
{
  void_void_fn test_i386_basic_asm_1
    = get_test_fn (result, "test_i386_basic_asm_1");
  CHECK_NON_NULL (test_i386_basic_asm_1);

  int *dst_ptr = (int *)gcc_jit_result_get_global (result, "dst");
  CHECK_NON_NULL (dst_ptr);
  int *src_ptr = (int *)gcc_jit_result_get_global (result, "src");
  CHECK_NON_NULL (src_ptr);

  *src_ptr = 42;
  *dst_ptr = 0;
  test_i386_basic_asm_1 ();
  CHECK_VALUE (*src_ptr, 42);
  CHECK_VALUE (*dst_ptr, 43);
}

/**********************************************************************
 test_i386_basic_asm_2: test of symbolic names and clobbers
 **********************************************************************/

/* Create the equivalent of:
     uint32_t test_i386_basic_asm_2 (uint32_t Mask)
     {
       uint32_t Index;
       // Quote from here in docs/cp/topics/asm.rst: example 2: C
       asm ("bsfl %[aMask], %[aIndex]"
            : [aIndex] "=r" (Index)
            : [aMask] "r" (Mask)
            : "cc");
       // Quote up to here in docs/cp/topics/asm.rst: example 2: C
       return Index;
     }
   i.e. return the first bit set in "Mask"

   This exercises symbolic names and clobbers.  */

static void
create_test_i386_basic_asm_2 (gcc_jit_context *c_ctxt)
{
  gccjit::context ctxt (c_ctxt);
  gccjit::type uint32_type = ctxt.get_int_type (4, 0);
  gccjit::param mask = ctxt.new_param (uint32_type, "Mask");
  std::vector<gccjit::param> params {mask};
  gccjit::function func = ctxt.new_function (GCC_JIT_FUNCTION_EXPORTED,
					     uint32_type,
					     "test_i386_basic_asm_2",
					     params, 0);
  gccjit::lvalue index = func.new_local (uint32_type, "Index");
  gccjit::block block = func.new_block ("initial");
  gccjit::extended_asm ext_asm =
  /* Quote from here in docs/cp/topics/asm.rst: example 2: jit.  */
    block.add_extended_asm ("bsfl %[aMask], %[aIndex]")
    .add_output_operand ("aIndex", "=r", index)
    .add_input_operand ("aMask", "r", mask)
    .add_clobber ("cc");
  /* Quote up to here in docs/cp/topics/asm.rst: example 2: jit.  */

  std::string desc = ext_asm.get_debug_string ();
  CHECK_STRING_VALUE
    (desc.c_str (),
     "asm (\"bsfl %[aMask], %[aIndex]\""
     " : [aIndex] \"=r\" (Index) : [aMask] \"r\" (Mask) : \"cc\")");

  block.end_with_return (index);
}

static void
verify_code_2 (gcc_jit_context *ctxt, gcc_jit_result *result)
{
  typedef uint32_t (*fntype) (uint32_t);
  fntype test_i386_basic_asm_2
    = (fntype)gcc_jit_result_get_code (result, "test_i386_basic_asm_2");
  CHECK_NON_NULL (test_i386_basic_asm_2);

  CHECK_VALUE (test_i386_basic_asm_2 (1), 0);
  CHECK_VALUE (test_i386_basic_asm_2 (2), 1);
  CHECK_VALUE (test_i386_basic_asm_2 (4), 2);
  CHECK_VALUE (test_i386_basic_asm_2 (8), 3);
}

/**********************************************************************
 test_i386_basic_asm_3a/b: test of control flow: "asm goto"
 **********************************************************************/

/* Create the equivalent of:

     int test_i386_basic_asm_3a (int p1, int p2)
     {
       asm goto ("btl %1, %0\n\t"
		 "jc %l2"
		 : // No outputs
		 : "r" (p1), "r" (p2)
		 : "cc"
		 : carry);

       return 0;

      carry:
       return 1;
     }

    or (the "_3b" variant) using a name rather than a number for the goto
    label:

       // Quote from here in docs/cp/topics/asm.rst: example 3b: C
       asm goto ("btl %1, %0\n\t"
                 "jc %l[carry]"
                 : // No outputs
                 : "r" (p1), "r" (p2)
                 : "cc"
                 : carry);
       // Quote up to here in docs/cp/topics/asm.rst: example 3b: C

    This exercises control flow with an asm.  */

static void
create_test_i386_basic_asm_3 (gcc_jit_context *c_ctxt,
			      const char *funcname,
			      int use_name)
{
  gccjit::context ctxt (c_ctxt);
  gccjit::type int_type = ctxt.get_type (GCC_JIT_TYPE_INT);
  gccjit::param p1 = ctxt.new_param (int_type, "p1");
  gccjit::param p2 = ctxt.new_param (int_type, "p2");
  std::vector<gccjit::param> params ({p1, p2});
  gccjit::function func = ctxt.new_function (GCC_JIT_FUNCTION_EXPORTED,
					     int_type,
					     funcname,
					     params, 0);
  gccjit::block b_start = func.new_block ("start");
  gccjit::block b_fallthru = func.new_block ("fallthru");
  gccjit::block b_carry = func.new_block ("carry");

  gccjit::rvalue zero = ctxt.new_rvalue (int_type, 0);
  gccjit::rvalue one = ctxt.new_rvalue (int_type, 1);

  /* Quote from here in docs/cp/topics/asm.rst: example 3: jit.  */
  const char *asm_template =
    (use_name
     ? /* Label referred to by name: "%l[carry]".  */
       ("btl %1, %0\n\t"
        "jc %l[carry]")
     : /* Label referred to numerically: "%l2".  */
       ("btl %1, %0\n\t"
        "jc %l2"));

  std::vector<gccjit::block> goto_blocks ({b_carry});
  gccjit::extended_asm ext_asm
    = (b_start.end_with_extended_asm_goto (asm_template,
					  goto_blocks,
					  &b_fallthru)
       .add_input_operand ("r", p1)
       .add_input_operand ("r", p2)
       .add_clobber ("cc"));
  /* Quote up to here in docs/cp/topics/asm.rst: example 3: jit.  */

  std::string desc = ext_asm.get_debug_string ();
  CHECK_STRING_VALUE
    (desc.c_str (),
     (use_name
      ? ("asm goto (\"btl %1, %0\\n\\tjc %l[carry]\" "
	 ":  : \"r\" (p1), \"r\" (p2) : \"cc\" "
	 ": carry [fallthrough: fallthru])")
      : ("asm goto (\"btl %1, %0\\n\\tjc %l2\" "
	 ":  : \"r\" (p1), \"r\" (p2) : \"cc\" "
	 ": carry [fallthrough: fallthru])")));

  b_fallthru.end_with_return (zero);
  b_carry.end_with_return (one);
}

static void
verify_code_3 (gcc_jit_context *ctxt, gcc_jit_result *result,
	       const char *funcname)
{
  typedef int (*test_i386_basic_asm_3_type) (int, int);

  test_i386_basic_asm_3_type test_i386_basic_asm_3
    = (test_i386_basic_asm_3_type) gcc_jit_result_get_code (result, funcname);
  CHECK_NON_NULL (test_i386_basic_asm_3);

  /* The fn should test bits, returning 0 or 1.  */
  /* Bit 0.  */
  CHECK_VALUE (test_i386_basic_asm_3 (0x0000, 0), 0);
  CHECK_VALUE (test_i386_basic_asm_3 (0x0001, 0), 1);
  CHECK_VALUE (test_i386_basic_asm_3 (0x0002, 0), 0);
  CHECK_VALUE (test_i386_basic_asm_3 (0x0003, 0), 1);
  CHECK_VALUE (test_i386_basic_asm_3 (0x0004, 0), 0);
  /* Bit 1.  */
  CHECK_VALUE (test_i386_basic_asm_3 (0x0000, 1), 0);
  CHECK_VALUE (test_i386_basic_asm_3 (0x0001, 1), 0);
  CHECK_VALUE (test_i386_basic_asm_3 (0x0002, 1), 1);
  CHECK_VALUE (test_i386_basic_asm_3 (0x0003, 1), 1);
  CHECK_VALUE (test_i386_basic_asm_3 (0x0004, 1), 0);

  for (int i = 0; i < 15; i++)
    {
      CHECK_VALUE (test_i386_basic_asm_3 (0x0000, i), 0);
      CHECK_VALUE (test_i386_basic_asm_3 (0xffff, i), 1);
    }
}

/**********************************************************************
 test_i386_basic_asm_4: test of "volatile"
 **********************************************************************/

/* Create the equivalent of:
     uint64_t test_i386_basic_asm_4 (void)
     {
       uint64_t start_time, end_time;

       // Get start time
       asm volatile ("rdtsc\n\t"    // Returns the time in EDX:EAX.
                     "shl $32, %%rdx\n\t"  // Shift the upper bits left.
                     "or %%rdx, %0"        // 'Or' in the lower bits.
                     : "=a" (start_time)
                     :
                     : "rdx");

       // could do other work here

       // Get end time
       asm volatile ("rdtsc\n\t"    // Returns the time in EDX:EAX.
                     "shl $32, %%rdx\n\t"  // Shift the upper bits left.
                     "or %%rdx, %0"        // 'Or' in the lower bits.
                     : "=a" (start_time)
                     :
                     : "rdx");

       // Get elapsed time
       return end_time - start_time;
     }

   This exercises "volatile"; without it, the optimizer can assume that
   both asm generate the same value and thus the time difference is zero.  */

static void
add_rdtsc (gccjit::block block, gccjit::lvalue msr)
{
  /* Quote from here in docs/cp/topics/asm.rst: example 4: jit.  */
  gccjit::extended_asm ext_asm
    = block.add_extended_asm
	("rdtsc\n\t"  /* Returns the time in EDX:EAX.  */
	 "shl $32, %%rdx\n\t"  /* Shift the upper bits left.  */
	 "or %%rdx, %0")  /* 'Or' in the lower bits.  */
    .set_volatile_flag (true)
    .add_output_operand ("=a", msr)
    .add_clobber ("rdx");
  /* Quote up to here in docs/cp/topics/asm.rst: example 4: jit.  */

  std::string desc = ext_asm.get_debug_string ();
  CHECK_STRING_STARTS_WITH (desc.c_str (), "asm volatile (");
}

static void
create_test_i386_basic_asm_4 (gcc_jit_context *c_ctxt)
{
  gccjit::context ctxt (c_ctxt);
  gccjit::type uint64_type = ctxt.get_int_type (8, 0);
  std::vector<gccjit::param> params;
  gccjit::function func = ctxt.new_function (GCC_JIT_FUNCTION_EXPORTED,
					      uint64_type,
					      "test_i386_basic_asm_4",
					     params, 0);
  gccjit::block block = func.new_block ();

  gccjit::lvalue start_time = func.new_local (uint64_type, "start_time");
  add_rdtsc (block, start_time);

  block.add_comment ("other work here");

  gccjit::lvalue end_time = func.new_local (uint64_type, "end_time");
  add_rdtsc (block, end_time);

  block.end_with_return (end_time - start_time);
}

static void
verify_code_4 (gcc_jit_context *ctxt, gcc_jit_result *result)
{
  typedef uint64_t (*fntype) (void);
  fntype test_i386_basic_asm_4
    = (fntype)gcc_jit_result_get_code (result, "test_i386_basic_asm_4");

  CHECK_NON_NULL (test_i386_basic_asm_4);

  test_i386_basic_asm_4 ();
}

/**********************************************************************
 test_i386_basic_asm_5: test of top-level asm
 **********************************************************************/

/* Create the equivalent of:

   // Quote from here in docs/cp/topics/asm.rst: example 5: C
     asm ("\t.pushsection .text\n"
          "\t.globl add_asm\n"
          "\t.type add_asm, @function\n"
          "add_asm:\n"
          "\tmovq %rdi, %rax\n"
          "\tadd %rsi, %rax\n"
          "\tret\n"
          "\t.popsection\n");
   // Quote up to here in docs/cp/topics/asm.rst: example 5: C

   to add a simple function ("add_asm") directly in assembly language.  */

static void
create_test_i386_basic_asm_5 (gcc_jit_context *c_ctxt)
{
  gccjit::context ctxt (c_ctxt);
#if __APPLE__
  /* Darwin's assemblers do not support push/pop section, do not use .type
     and external symbols should use __USER_LABEL_PREFIX__.  */
  ctxt.add_top_level_asm ("\t.text\n"
                          "\t.globl _add_asm\n"
                          "_add_asm:\n"
                          "\tmovq %rdi, %rax\n"
                          "\tadd %rsi, %rax\n"
                          "\tret\n"
                          "\t# some asm here\n");
#else
  /* Quote from here in docs/cp/topics/asm.rst: example 5: jit.  */
  ctxt.add_top_level_asm ("\t.pushsection .text\n"
                          "\t.globl add_asm\n"
                          "\t.type add_asm, @function\n"
                          "add_asm:\n"
                          "\tmovq %rdi, %rax\n"
                          "\tadd %rsi, %rax\n"
                          "\tret\n"
                          "\t# some asm here\n"
                          "\t.popsection\n");
  /* Quote up to here in docs/cp/topics/asm.rst: example 5: jit.  */
#endif
}

static void
verify_code_5 (gcc_jit_context *ctxt, gcc_jit_result *result)
{
  typedef int (*test_i386_basic_asm_5_type) (int, int);
  test_i386_basic_asm_5_type test_i386_basic_asm_5
    = (test_i386_basic_asm_5_type) gcc_jit_result_get_code (result, "add_asm");
  CHECK_NON_NULL (test_i386_basic_asm_5);

  CHECK_VALUE (test_i386_basic_asm_5 (2, 2), 4);
  CHECK_VALUE (test_i386_basic_asm_5 (20, 7), 27);
}

/**********************************************************************
 Code for harness
 **********************************************************************/

void
create_code (gcc_jit_context *ctxt, void *user_data)
{
  create_test_i386_basic_asm_1 (ctxt);
  create_test_i386_basic_asm_2 (ctxt);
  create_test_i386_basic_asm_3 (ctxt, "test_i386_basic_asm_3a", 0);
  create_test_i386_basic_asm_3 (ctxt, "test_i386_basic_asm_3b", 1);
  create_test_i386_basic_asm_4 (ctxt);
  create_test_i386_basic_asm_5 (ctxt);
}

void
verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
{
  CHECK_NON_NULL (result);
  verify_code_1 (ctxt, result);
  verify_code_2 (ctxt, result);
  verify_code_3 (ctxt, result, "test_i386_basic_asm_3a");
  verify_code_3 (ctxt, result, "test_i386_basic_asm_3b");
  verify_code_4 (ctxt, result);
  verify_code_5 (ctxt, result);
}