#encoding=utf-8

import argparse
import ast
import intel_genxml
import re
import sys
import copy
import textwrap
from util import *

license =  """/*
 * Copyright (C) 2016 Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */
"""

pack_header = """%(license)s

/* Instructions, enums and structures for %(platform)s.
 *
 * This file has been generated, do not hand edit.
 */

#ifndef %(guard)s
#define %(guard)s

#ifndef __OPENCL_VERSION__
#include <stdio.h>
#include "util/bitpack_helpers.h"
#include "genX_helpers.h"
#else
#include "genX_cl_helpers.h"
#endif

"""

def num_from_str(num_str):
    if num_str.lower().startswith('0x'):
        return int(num_str, base=16)

    assert not num_str.startswith('0'), 'octals numbers not allowed'
    return int(num_str)

def bool_from_str(bool_str):
    options = { "true": True, "false": False }
    return options[bool_str];

class Field(object):
    ufixed_pattern = re.compile(r"u(\d+)\.(\d+)")
    sfixed_pattern = re.compile(r"s(\d+)\.(\d+)")

    def __init__(self, parser, attrs):
        self.parser = parser
        if "name" in attrs:
            self.name = safe_name(attrs["name"])

        dword = int(attrs["dword"])
        end_bit, start_bit = map(int, attrs["bits"].split(":"))

        self.start = dword * 32 + start_bit
        self.end = dword * 32 + end_bit

        self.type = attrs["type"]
        self.nonzero = bool_from_str(attrs.get("nonzero", "false"))
        self.prefix = attrs["prefix"] if "prefix" in attrs else None

        assert self.start <= self.end, \
               'field {} has end ({}) < start ({})'.format(self.name, self.end,
                                                           self.start)
        if self.type == 'bool':
            assert self.end == self.start, \
                   'bool field ({}) is too wide'.format(self.name)

        if "default" in attrs:
            # Base 0 recognizes 0x, 0o, 0b prefixes in addition to decimal ints.
            self.default = int(attrs["default"], base=0)
        else:
            self.default = None

        ufixed_match = Field.ufixed_pattern.match(self.type)
        if ufixed_match:
            self.type = 'ufixed'
            self.fractional_size = int(ufixed_match.group(2))

        sfixed_match = Field.sfixed_pattern.match(self.type)
        if sfixed_match:
            self.type = 'sfixed'
            self.fractional_size = int(sfixed_match.group(2))

    def is_builtin_type(self):
        builtins =  [ 'address', 'bool', 'float', 'ufixed',
                      'offset', 'sfixed', 'offset', 'int', 'uint',
                      'mbo', 'mbz' ]
        return self.type in builtins

    def is_struct_type(self):
        return self.type in self.parser.structs

    def is_enum_type(self):
        return self.type in self.parser.enums

    def emit_template_struct(self, dim):
        if self.type == 'address':
            type = 'uint64_t' if self.parser.opencl else '__gen_address_type'
        elif self.type == 'bool':
            type = 'bool'
        elif self.type == 'float':
            type = 'float'
        elif self.type == 'ufixed':
            type = 'float'
        elif self.type == 'sfixed':
            type = 'float'
        elif self.type == 'uint' and self.end - self.start > 32:
            type = 'uint64_t'
        elif self.type == 'offset':
            type = 'uint64_t'
        elif self.type == 'int':
            type = 'int32_t'
        elif self.type == 'uint':
            type = 'uint32_t'
        elif self.is_struct_type():
            type = 'struct ' + self.parser.gen_prefix(safe_name(self.type))
        elif self.is_enum_type():
            type = 'enum ' + self.parser.gen_prefix(safe_name(self.type))
        elif self.type == 'mbo' or self.type == 'mbz':
            return
        else:
            print("#error unhandled type: %s" % self.type)
            return

        print("   %-36s %s%s;" % (type, self.name, dim))

        prefix = self.prefix + '_' if self.prefix else ''

        for value in self.values:
            name = value.name
            if self.prefix and value.name[0] == '_':
                name = name[1:]

            print("#define %-40s %d" % (prefix + name, value.value))

class Group(object):
    def __init__(self, parser, parent, start, count, size):
        self.parser = parser
        self.parent = parent
        self.start = start
        self.count = count
        self.size = size
        self.fields = []

    def emit_template_struct(self, dim):
        if self.count == 0:
            print("   /* variable length fields follow */")
        else:
            if self.count > 1:
                dim = "%s[%d]" % (dim, self.count)

            for field in self.fields:
                field.emit_template_struct(dim)

    class DWord:
        def __init__(self):
            self.size = 32
            self.fields = []
            self.address = None

    def collect_dwords(self, dwords, start, dim):
        for field in self.fields:
            if isinstance(field, Group):
                if field.count == 1:
                    field.collect_dwords(dwords, start + field.start, dim)
                else:
                    for i in range(field.count):
                        field.collect_dwords(dwords,
                                             start + field.start + i * field.size,
                                             "%s[%d]" % (dim, i))
                continue

            index = (start + field.start) // 32
            if not index in dwords:
                dwords[index] = self.DWord()

            clone = copy.copy(field)
            clone.start = clone.start + start
            clone.end = clone.end + start
            clone.dim = dim
            dwords[index].fields.append(clone)

            if field.type == "address":
                # assert dwords[index].address == None
                dwords[index].address = clone

            # Coalesce all the dwords covered by this field. The two cases we
            # handle are where multiple fields are in a 64 bit word (typically
            # and address and a few bits) or where a single struct field
            # completely covers multiple dwords.
            while index < (start + field.end) // 32:
                if index + 1 in dwords and not dwords[index] == dwords[index + 1]:
                    dwords[index].fields.extend(dwords[index + 1].fields)
                dwords[index].size = 64
                dwords[index + 1] = dwords[index]
                index = index + 1

    def collect_dwords_and_length(self, repack=False):
        dwords = {}
        self.collect_dwords(dwords, 0, "")

        # Determine number of dwords in this group. If we have a size, use
        # that, since that'll account for MBZ dwords at the end of a group
        # (like dword 8 on BDW+ 3DSTATE_HS). Otherwise, use the largest dword
        # index we've seen plus one.
        if self.size > 0:
            length = self.size // 32
        elif dwords:
            length = max(dwords.keys()) + 1
        else:
            length = 0

        return (dwords, length)

    def emit_pack_function(self, dwords, length, repack=False):
        for index in range(length):
            # Handle MBZ dwords
            if not index in dwords:
                print("")
                print("   dw[%d] = 0;" % index)
                continue

            # For 64 bit dwords, we aliased the two dword entries in the dword
            # dict it occupies. Now that we're emitting the pack function,
            # skip the duplicate entries.
            dw = dwords[index]
            if index > 0 and index - 1 in dwords and dw == dwords[index - 1]:
                continue

            # Special case: only one field and it's a struct at the beginning
            # of the dword. In this case we pack directly into the
            # destination. This is the only way we handle embedded structs
            # larger than 32 bits.
            if len(dw.fields) == 1:
                field = dw.fields[0]
                name = field.name + field.dim
                if field.is_struct_type() and field.start % 32 == 0:
                    print("")
                    if repack:
                        if self.parser.opencl:
                            print("   %s_repack(&dw[%d], &origin[%d], &values->%s);" %
                                  (self.parser.gen_prefix(safe_name(field.type)), index, index, name))
                        else:
                            print("   %s_pack(data, &dw[%d], &origin[%d], &values->%s);" %
                                  (self.parser.gen_prefix(safe_name(field.type)), index, index, name))
                    else:
                        if self.parser.opencl:
                            print("   %s_pack(&dw[%d], &values->%s);" %
                                  (self.parser.gen_prefix(safe_name(field.type)), index, name))
                        else:
                            print("   %s_pack(data, &dw[%d], &values->%s);" %
                                  (self.parser.gen_prefix(safe_name(field.type)), index, name))
                    continue

            # Pack any fields of struct type first so we have integer values
            # to the dword for those fields.
            field_index = 0
            for field in dw.fields:
                if isinstance(field, Field) and field.is_struct_type():
                    name = field.name + field.dim
                    print("")
                    print("   uint32_t v%d_%d;" % (index, field_index))
                    if repack:
                        if self.parser.opencl:
                            print("   %s_repack(&v%d_%d, &origin[%d], &values->%s);" %
                                  (self.parser.gen_prefix(safe_name(field.type)), index, field_index, index, name))
                        else:
                            print("   %s_repack(data, &v%d_%d, &origin[%d], &values->%s);" %
                                  (self.parser.gen_prefix(safe_name(field.type)), index, field_index, index, name))
                    else:
                        if self.parser.opencl:
                            print("   %s_pack(&v%d_%d, &values->%s);" %
                                  (self.parser.gen_prefix(safe_name(field.type)), index, field_index, name))
                        else:
                            print("   %s_pack(data, &v%d_%d, &values->%s);" %
                                  (self.parser.gen_prefix(safe_name(field.type)), index, field_index, name))
                    field_index = field_index + 1

            print("")
            dword_start = index * 32
            if dw.address == None:
                address_count = 0
            else:
                address_count = 1

            # Assert in dont_use values
            for field in dw.fields:
                for value in field.values:
                    if value.dont_use:
                        print("   assert(values->%s != %s);" %
                              (field.name, field.prefix + "_" + value.name))

            if dw.size == 32 and dw.address == None:
                v = None
                print("   dw[%d] =" % index)
            elif len(dw.fields) > address_count or repack:
                v = "v%d" % index
                print("   const uint%d_t %s =" % (dw.size, v))
            else:
                v = "0"

            field_index = 0
            non_address_fields = []

            if repack:
                non_address_fields.append("origin[%d]" % index)
                if dw.size > 32:
                    non_address_fields.append("((uint64_t)origin[%d] << 32)" % (index + 1))

            for field in dw.fields:
                if field.type != "mbo" and field.type != "mbz" and field.type != "repack":
                    name = field.name + field.dim

                nz = "_nonzero" if field.nonzero else ""

                if field.type == "repack":
                    non_address_fields.append("origin[%d]" % index)
                elif field.type == "mbo":
                    non_address_fields.append("util_bitpack_ones(%d, %d)" % \
                        (field.start - dword_start, field.end - dword_start))
                elif field.type == "mbz":
                    assert not field.nonzero
                elif field.type == "address":
                    pass
                elif field.type == "uint":
                    non_address_fields.append("util_bitpack_uint%s(values->%s, %d, %d)" % \
                        (nz, name, field.start - dword_start, field.end - dword_start))
                elif field.is_enum_type():
                    non_address_fields.append("util_bitpack_uint%s(values->%s, %d, %d)" % \
                        (nz, name, field.start - dword_start, field.end - dword_start))
                elif field.type == "int":
                    non_address_fields.append("util_bitpack_sint%s(values->%s, %d, %d)" % \
                        (nz, name, field.start - dword_start, field.end - dword_start))
                elif field.type == "bool":
                    non_address_fields.append("util_bitpack_uint%s(values->%s, %d, %d)" % \
                        (nz, name, field.start - dword_start, field.end - dword_start))
                elif field.type == "float":
                    non_address_fields.append("util_bitpack_float%s(values->%s)" % (nz, name))
                elif field.type == "offset":
                    non_address_fields.append("__gen_offset%s(values->%s, %d, %d)" % \
                        (nz, name, field.start - dword_start, field.end - dword_start))
                elif field.type == 'ufixed':
                    non_address_fields.append("util_bitpack_ufixed%s(values->%s, %d, %d, %d)" % \
                        (nz, name, field.start - dword_start, field.end - dword_start, field.fractional_size))
                elif field.type == 'sfixed':
                    non_address_fields.append("util_bitpack_sfixed%s(values->%s, %d, %d, %d)" % \
                        (nz, name, field.start - dword_start, field.end - dword_start, field.fractional_size))
                elif field.is_struct_type():
                    non_address_fields.append("util_bitpack_uint(v%d_%d, %d, %d)" % \
                        (index, field_index, field.start - dword_start, field.end - dword_start))
                    field_index = field_index + 1
                else:
                    non_address_fields.append("/* unhandled field %s, type %s */\n" % \
                                              (name, field.type))

            if non_address_fields:
                print(" |\n".join("      " + f for f in non_address_fields) + ";")

            if dw.size == 32:
                if dw.address:
                    if self.parser.opencl:
                        print("   dw[%d] = __gen_address(values->%s, %d, %d) | %s;" %
                              (index, dw.address.name + field.dim,
                               dw.address.start - dword_start, dw.address.end - dword_start, v))
                    else:
                        print("   dw[%d] = __gen_address(data, &dw[%d], values->%s, %s, %d, %d);" %
                              (index, index, dw.address.name + field.dim, v,
                               dw.address.start - dword_start, dw.address.end - dword_start))
                continue

            if dw.address:
                v_address = "v%d_address" % index
                if self.parser.opencl:
                    print("   const uint64_t %s =\n      __gen_address(values->%s, %d, %d) | %s;" %
                          (v_address, dw.address.name + field.dim,
                           dw.address.start - dword_start, dw.address.end - dword_start, v))
                else:
                    print("   const uint64_t %s =\n      __gen_address(data, &dw[%d], values->%s, %s, %d, %d);" %
                          (v_address, index, dw.address.name + field.dim, v,
                           dw.address.start - dword_start, dw.address.end - dword_start))
                if len(dw.fields) > address_count:
                    print("   dw[%d] = %s;" % (index, v_address))
                    print("   dw[%d] = (%s >> 32) | (%s >> 32);" % (index + 1, v_address, v))
                    continue
                else:
                    v = v_address
            print("   dw[%d] = %s;" % (index, v))
            print("   dw[%d] = %s >> 32;" % (index + 1, v))

class Value(object):
    def __init__(self, attrs):
        self.name = safe_name(attrs["name"])
        self.value = ast.literal_eval(attrs["value"])
        self.dont_use = int(attrs["dont_use"]) != 0 if "dont_use" in attrs else False

class Parser(object):
    def __init__(self, opencl, repack):
        self.instruction = None
        self.structs = {}
        # Set of enum names we've seen.
        self.enums = set()
        self.registers = {}
        self.opencl = opencl
        self.repack = repack

    def gen_prefix(self, name):
        if name[0] == "_":
            return 'GFX%s%s' % (self.gen, name)
        return 'GFX%s_%s' % (self.gen, name)

    def gen_guard(self):
        if self.opencl:
            return self.gen_prefix("{0}_CL_PACK_H".format(self.platform))
        return self.gen_prefix("{0}_PACK_H".format(self.platform))

    def process_item(self, item):
        name = item.tag
        assert name != "genxml"
        attrs = item.attrib

        if name in ("instruction", "struct", "register"):
            if name == "instruction":
                self.instruction = safe_name(attrs["name"])
                self.length_bias = int(attrs["bias"])
            elif name == "struct":
                self.struct = safe_name(attrs["name"])
                self.structs[attrs["name"]] = 1
            elif name == "register":
                self.register = safe_name(attrs["name"])
                self.reg_num = num_from_str(attrs["num"])
                self.registers[attrs["name"]] = 1
            if "length" in attrs:
                self.length = int(attrs["length"])
                size = self.length * 32
            else:
                self.length = None
                size = 0
            self.group = Group(self, None, 0, 1, size)

        elif name == "group":
            dword = int(attrs["dword"])
            offset_bits = int(attrs.get("offset_bits", 0))
            start = dword * 32 + offset_bits


            group = Group(self, self.group,
                          start, int(attrs["count"]), int(attrs["size"]))
            self.group.fields.append(group)
            self.group = group
        elif name == "field":
            self.group.fields.append(Field(self, attrs))
            self.values = []
        elif name == "enum":
            self.values = []
            self.enum = safe_name(attrs["name"])
            self.enums.add(attrs["name"])
            if "prefix" in attrs:
                self.prefix = safe_name(attrs["prefix"])
            else:
                self.prefix = None
        elif name == "value":
            self.values.append(Value(attrs))
        elif name in ("import", "exclude"):
            pass
        else:
            assert False

        for child_item in item:
            self.process_item(child_item)

        if name  == "instruction":
            self.emit_instruction()
            self.instruction = None
            self.group = None
        elif name == "struct":
            self.emit_struct()
            self.struct = None
            self.group = None
        elif name == "register":
            self.emit_register()
            self.register = None
            self.reg_num = None
            self.group = None
        elif name == "group":
            self.group = self.group.parent
        elif name  == "field":
            self.group.fields[-1].values = self.values
        elif name  == "enum":
            self.emit_enum()
            self.enum = None
        elif name in ("import", "exclude", "value"):
            pass
        else:
            assert False

    def emit_template_struct(self, name, group):
        print("struct %s {" % self.gen_prefix(name))
        group.emit_template_struct("")
        print("};\n")

    def emit_pack_function(self, name, group, repack=False):
        name = self.gen_prefix(name)
        if repack:
            if self.opencl:
                print(textwrap.dedent("""\
                static inline __attribute__((always_inline)) void
                %s_repack(__attribute__((unused)) global void * restrict dst,
                        %s__attribute__((unused)) global const uint32_t * origin,
                        %s__attribute__((unused)) private const struct %s * restrict values)
                {""") % (name, ' ' * len(name), ' ' * len(name), name))
            else:
                print(textwrap.dedent("""\
                static inline __attribute__((always_inline)) void
                %s_repack(__attribute__((unused)) __gen_user_data *data,
                        %s__attribute__((unused)) void * restrict dst,
                        %s__attribute__((unused)) global const uint32_t * origin,
                        %s__attribute__((unused)) const struct %s * restrict values)
                {""") % (name, ' ' * len(name), ' ' * len(name), ' ' * len(name), name))
        else:
            if self.opencl:
                print(textwrap.dedent("""\
                static inline __attribute__((always_inline)) void
                %s_pack(__attribute__((unused)) global void * restrict dst,
                      %s__attribute__((unused)) private const struct %s * restrict values)
                {""") % (name, ' ' * len(name), name))
            else:
                print(textwrap.dedent("""\
                static inline __attribute__((always_inline)) void
                %s_pack(__attribute__((unused)) __gen_user_data *data,
                      %s__attribute__((unused)) void * restrict dst,
                      %s__attribute__((unused)) const struct %s * restrict values)
                {""") % (name, ' ' * len(name), ' ' * len(name), name))

        (dwords, length) = group.collect_dwords_and_length(repack)
        if length:
            # Cast dst to make header C++ friendly
            type_name = "global uint32_t *" if self.opencl else "uint32_t * restrict"
            print("   %s dw = (%s) dst;" % (type_name, type_name))

            group.emit_pack_function(dwords, length, repack)

        print("}\n")

    def emit_instruction(self):
        name = self.instruction

        if not self.length is None:
            print('#define %-33s %6d' %
                  (self.gen_prefix(name + "_length"), self.length))
        print('#define %-33s %6d' %
              (self.gen_prefix(name + "_length_bias"), self.length_bias))

        default_fields = []
        for field in self.group.fields:
            if not isinstance(field, Field):
                continue
            if field.default is None:
                continue

            if field.is_builtin_type():
                default_fields.append("   .%-35s = %6d" % (field.name, field.default))
            else:
                # Default values should not apply to structures
                assert field.is_enum_type()
                default_fields.append("   .%-35s = (enum %s) %6d" % (field.name, self.gen_prefix(safe_name(field.type)), field.default))

        if default_fields:
            print('#define %-40s\\' % (self.gen_prefix(name + '_header')))
            print(",  \\\n".join(default_fields))
            print('')

        self.emit_template_struct(self.instruction, self.group)
        self.emit_pack_function(self.instruction, self.group)
        if self.repack:
            self.emit_pack_function(self.instruction, self.group, repack=True)

    def emit_register(self):
        name = self.register
        if not self.reg_num is None:
            print('#define %-33s 0x%04x' %
                  (self.gen_prefix(name + "_num"), self.reg_num))

        if not self.length is None:
            print('#define %-33s %6d' %
                  (self.gen_prefix(name + "_length"), self.length))

        self.emit_template_struct(self.register, self.group)
        self.emit_pack_function(self.register, self.group)

    def emit_struct(self):
        name = self.struct
        if not self.length is None:
            print('#define %-33s %6d' %
                  (self.gen_prefix(name + "_length"), self.length))

        self.emit_template_struct(self.struct, self.group)
        self.emit_pack_function(self.struct, self.group)
        if self.repack:
            self.emit_pack_function(self.struct, self.group, repack=True)

    def emit_enum(self):
        print('enum %s {' % self.gen_prefix(self.enum))
        for value in self.values:
            if self.prefix:
                name = self.prefix + "_" + value.name
            else:
                name = value.name
            print('   %-36s = %6d,' % (name.upper(), value.value))
        print('};\n')

    def emit_genxml(self, genxml):
        root = genxml.et.getroot()
        self.platform = root.attrib["name"]
        self.gen = root.attrib["gen"].replace('.', '')
        print(pack_header % {'license': license, 'platform': self.platform, 'guard': self.gen_guard()})
        for item in root:
            self.process_item(item)
        print('#endif /* %s */' % self.gen_guard())

def parse_args():
    p = argparse.ArgumentParser()
    p.add_argument('xml_source', metavar='XML_SOURCE',
                   help="Input xml file")
    p.add_argument('--engines', nargs='?', type=str, default='render',
                   help="Comma-separated list of engines whose instructions should be parsed (default: %(default)s)")
    p.add_argument('--include-symbols', nargs='?', type=str, action='store',
                   help="List of instruction/structures to generate")
    p.add_argument('--opencl', action='store_true', help="Generate OpenCL code")
    p.add_argument('--repack', action='store_true', help="Emit repacking code")

    pargs = p.parse_args()

    if pargs.engines is None:
        print("No engines specified")
        sys.exit(1)

    return pargs

def main():
    pargs = parse_args()

    engines = set(pargs.engines.split(','))
    valid_engines = [ 'render', 'blitter', 'video', 'compute' ]
    if engines - set(valid_engines):
        print("Invalid engine specified, valid engines are:\n")
        for e in valid_engines:
            print("\t%s" % e)
        sys.exit(1)

    genxml = intel_genxml.GenXml(pargs.xml_source)

    genxml.merge_imported()
    genxml.filter_engines(engines)
    if pargs.include_symbols:
        genxml.filter_symbols(pargs.include_symbols.split(','))
    p = Parser(pargs.opencl, pargs.repack)
    p.emit_genxml(genxml)

if __name__ == '__main__':
    main()
