/*

 * Generic functionality for handling accesses to the PCI header from the

 * configuration space.

 *

 * Copyright (C) 2017 Citrix Systems R&D

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms and conditions of the GNU General Public

 * License, version 2, as published by the Free Software Foundation.

 *

 * This program 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 <errno.h>

//#include <inttypes.h>

//#include <string.h>

#include <xen/errno.h>

#include <xen/guest_access.h>

#include <xen/types.h>

#include <public/sysctl.h>

//#include "InstrProfData.inc"

enum llvm_profile_kind

{

  indirect_call,

  memop_size,

  num_kinds,

};

struct llvm_function_header {

  /*

   * Total size in bytes including this field. It must be a multiple

   * of sizeof(uint64_t).

   */

  uint32_t size;

  /*

   *The number of value profile kinds that has value profile data.

   * In this implementation, a value profile kind is considered to

   * have profile data if the number of value profile sites for the

   * kind is not zero. More aggressively, the implementation can

   * choose to check the actual data value: if none of the value sites

   * has any profiled values, the kind can be skipped.

   */

  uint32_t nr_value_kinds;

};

struct llvm_profile_node

{

    struct llvm_profile_node_val {

        uint64_t value;

        uint64_t count;

    } val;

    struct llvm_profile_node *next;

};

struct llvm_profile_data

{

    uint64_t name_ref;

    uint64_t function_hash;

    void *counter;

    void *function;

    struct llvm_profile_node **values;

    uint32_t nr_counters;

    uint16_t nr_value_sites[num_kinds];

};

struct llvm_profile_header {

    uint64_t magic;

    uint64_t version;

    uint64_t data_size;

    uint64_t counters_size;

    uint64_t names_size;

    uint64_t counters_delta;

    uint64_t names_delta;

    uint64_t value_kind_last;

};

int __llvm_profile_runtime;

#define INSTR_PROF_RAW_MAGIC_64 (uint64_t)255 << 56 | (uint64_t)'l' << 48 | \

       (uint64_t)'p' << 40 | (uint64_t)'r' << 32 | (uint64_t)'o' << 24 |  \

        (uint64_t)'f' << 16 | (uint64_t)'r' << 8 | (uint64_t)129

#define INSTR_PROF_RAW_MAGIC_32 (uint64_t)255 << 56 | (uint64_t)'l' << 48 | \

       (uint64_t)'p' << 40 | (uint64_t)'r' << 32 | (uint64_t)'o' << 24 |  \

        (uint64_t)'f' << 16 | (uint64_t)'R' << 8 | (uint64_t)129

extern struct llvm_profile_data __start___llvm_prf_data;

extern struct llvm_profile_data __stop___llvm_prf_data;

extern uint64_t __start___llvm_prf_cnts;

extern uint64_t __stop___llvm_prf_cnts;

extern char __start___llvm_prf_names;

extern char __stop___llvm_prf_names;

static uint64_t *__llvm_profile_begin_counters(void)

{

  return &__start___llvm_prf_cnts;

}

static uint64_t *__llvm_profile_end_counters(void)

{

  return &__stop___llvm_prf_cnts;

}

static const struct llvm_profile_data * __llvm_profile_begin_data(void)

{

  return &__start___llvm_prf_data;

}

static const struct llvm_profile_data * __llvm_profile_end_data(void)

{

  return &__stop___llvm_prf_data;

}

static const char *__llvm_profile_begin_names(void)

{

  return &__start___llvm_prf_names;

}

static const char *__llvm_profile_end_names(void)

{

  return &__stop___llvm_prf_names;

}

uint64_t __llvm_profile_get_data_size(const struct llvm_profile_data *Begin,

                                      const struct llvm_profile_data *End)

{

  uint64_t BeginI = (uint64_t)Begin, EndI = (uint64_t)End;

  return ((EndI + sizeof(struct llvm_profile_data) - 1) - BeginI) /

         sizeof(struct llvm_profile_data);

}

uint8_t __llvm_profile_get_num_padding_bytes(uint64_t SizeInBytes)

{

  return 7 & (sizeof(uint64_t) - SizeInBytes % sizeof(uint64_t));

}

void llvm_profile_reset_counters(void)

{

    const struct llvm_profile_data *data;

    memset(__llvm_profile_begin_counters(), 0,

           sizeof(uint64_t) * (__llvm_profile_end_counters() -

                               __llvm_profile_begin_counters()));

    for ( data = __llvm_profile_begin_data();

          data < __llvm_profile_end_data();

          data++ )

    {

        uint64_t site_count = 0;

        struct llvm_profile_node **nodes;

        uint32_t VKI, i;

        if ( !data->values )

          continue;

        nodes = data->values;

        for (VKI = 0; VKI <= num_kinds; VKI++)

            site_count += data->nr_value_sites[VKI];

        printk(XENLOG_INFO "site_count = %lu\n", site_count);

        for (i = 0; i < site_count; i++)

        {

            struct llvm_profile_node *node = nodes[i];

            while (node)

            {

                node->val.count = 0;

                node = node->next;

            }

        }

    }

}

void llvm_profile_write(XEN_GUEST_HANDLE_PARAM(char) buffer)

{

    const struct llvm_profile_data *DataBegin = __llvm_profile_begin_data();

    const struct llvm_profile_data *DataEnd = __llvm_profile_end_data();

    const uint64_t *CountersBegin = __llvm_profile_begin_counters();

    const uint64_t *CountersEnd = __llvm_profile_end_counters();

    const char *NamesBegin = __llvm_profile_begin_names();

    const char *NamesEnd = __llvm_profile_end_names();

    const uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);

    const uint64_t CountersSize = CountersEnd - CountersBegin;

    const uint64_t NamesSize = NamesEnd - NamesBegin;

    const uint8_t Padding = __llvm_profile_get_num_padding_bytes(NamesSize);

    struct llvm_profile_header header;

    unsigned int off = 0;

#if BITS_PER_LONG == 64

    header.magic = INSTR_PROF_RAW_MAGIC_64;

#else

    header.magic = INSTR_PROF_RAW_MAGIC_32;

#endif

    /* XXX: hardcoded version number... */

    header.version = 4;

    header.data_size = DataSize;

    header.counters_size = CountersSize;

    header.names_size = NamesSize;

    header.counters_delta = (uintptr_t)CountersBegin;

    header.names_delta = (uintptr_t)NamesBegin;

    header.value_kind_last = num_kinds - 1;

    /* Copy data into the buffer. */

    copy_to_guest_offset(buffer, off, (char *)&header, sizeof(struct llvm_profile_header));

    off += sizeof(struct llvm_profile_header);

    copy_to_guest_offset(buffer, off, (char *)DataBegin, DataSize * sizeof(struct llvm_profile_data));

    off += DataSize * sizeof(struct llvm_profile_data);

    copy_to_guest_offset(buffer, off, (char *)CountersBegin, CountersSize * sizeof(uint64_t));

    off += CountersSize * sizeof(uint64_t);

    copy_to_guest_offset(buffer, off, NamesBegin, NamesSize * sizeof(uint8_t));

    off += NamesSize * sizeof(uint8_t);

    clear_guest_offset(buffer, off, Padding * sizeof(uint8_t));

    off += Padding * sizeof(uint8_t);

}

size_t llvm_profile_get_size(void)

{

    //const struct llvm_profile_data *data;

    const struct llvm_profile_data *DataBegin = __llvm_profile_begin_data();

    const struct llvm_profile_data *DataEnd = __llvm_profile_end_data();

    const uint64_t *CountersBegin = __llvm_profile_begin_counters();

    const uint64_t *CountersEnd = __llvm_profile_end_counters();

    const char *NamesBegin = __llvm_profile_begin_names();

    const char *NamesEnd = __llvm_profile_end_names();

    const uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);

    const uint64_t CountersSize = CountersEnd - CountersBegin;

    const uint64_t NamesSize = NamesEnd - NamesBegin;

    const uint8_t Padding = __llvm_profile_get_num_padding_bytes(NamesSize);

    //size_t size = 0;

    //

    printk(XENLOG_INFO "Data size: %lu\n", DataSize);

    printk(XENLOG_INFO "Name size: %lu\n", NamesSize);

    printk(XENLOG_INFO "Counter size: %lu\n", CountersSize);

    printk(XENLOG_INFO "Padding size: %u\n", Padding);

    return sizeof(struct llvm_profile_header) +

           sizeof(struct llvm_profile_data) * DataSize +

           sizeof(uint64_t) * CountersSize + sizeof(uint8_t) * NamesSize +

           sizeof(uint8_t) * Padding;

#if 0

    for ( data = __llvm_profile_begin_data();

          data < __llvm_profile_end_data();

          data++ )

    {

        enum llvm_profile_kind kind;

        uint64_t site_count = 0;

        struct llvm_profile_node **nodes;

        uint32_t VKI, i;

        for ( kind = 0; kind < num_kinds; kind++ )

        {

          if ( !data->nr_value_sites[kind] )

            continue;

          else

            printf("data not null!\n!");

#if 0

        if ( !data->values )

          continue;

        nodes = data->values;

        for (VKI = 0; VKI <= num_kinds; VKI++)

            site_count += data->nr_value_sites[VKI];

        size += site_count * sizeof(struct llvm_function_header);

        for (i = 0; i < site_count; i++)

        {

            struct llvm_profile_node *node = nodes[i];

            while (node)

            {

                size += sizeof(struct llvm_profile_node_val);

                node = node->next;

            }

        }

#endif

        }

    }

#endif

    //return size;

}

int sysctl_gcov_op(struct xen_sysctl_gcov_op *op)

{

    switch ( op->cmd )

    {

    case XEN_SYSCTL_GCOV_get_size:

        op->size = llvm_profile_get_size();

        break;

    case XEN_SYSCTL_GCOV_reset:

        llvm_profile_reset_counters();

        break;

    case XEN_SYSCTL_GCOV_read:

    {

        XEN_GUEST_HANDLE_PARAM(char) buf;

        buf = guest_handle_cast(op->buffer, char);

        llvm_profile_write(buf);

        break;

    }

    default:

        return -ENOSYS;

    }

    return 0;

}