O3DE
/
DirectXShaderCompiler
spiegel van https://github.com/o3de/DirectXShaderCompiler


			
							1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060
							# Copyright (C) Microsoft Corporation. All rights reserved.
# This file is distributed under the University of Illinois Open Source License. See LICENSE.TXT for details.
import argparse
import functools
import collections
from hctdb import *

# get db singletons
g_db_dxil = None
def get_db_dxil():
    global g_db_dxil
    if g_db_dxil is None:
        g_db_dxil = db_dxil()
    return g_db_dxil
g_db_hlsl = None
def get_db_hlsl():
    global g_db_hlsl
    if g_db_hlsl is None:
      thisdir = os.path.dirname(os.path.realpath(__file__))
      with open(os.path.join(thisdir, "gen_intrin_main.txt"), "r") as f:
        g_db_hlsl = db_hlsl(f)
    return g_db_hlsl

def format_comment(prefix, val):
    "Formats a value with a line-comment prefix."
    result = ""
    line_width = 80
    content_width = line_width - len(prefix)
    l = len(val)
    while l:
        if l < content_width:
            result += prefix + val.strip()
            result += "\n"
            l = 0
        else:
            split_idx = val.rfind(" ", 0, content_width)
            result += prefix + val[:split_idx].strip()
            result += "\n"
            val = val[split_idx+1:]
            l = len(val)
    return result

def format_rst_table(list_of_tuples):
    "Produces a reStructuredText simple table from the specified list of tuples."
    # Calculate widths.
    widths = None
    for t in list_of_tuples:
        if widths is None:
            widths = [0] * len(t)
        for i, v in enumerate(t):
            widths[i] = max(widths[i], len(str(v)))
    # Build banner line.
    banner = ""
    for i, w in enumerate(widths):
        if i > 0:
            banner += " "
        banner += "=" * w
    banner += "\n"
    # Build the result.
    result = banner
    for i, t in enumerate(list_of_tuples):
        for j, v in enumerate(t):
            if j > 0:
                result += " "
            result += str(v)
            result += " " * (widths[j] - len(str(v)))
        result = result.rstrip()
        result += "\n"
        if i == 0:
            result += banner
    result += banner
    return result

def build_range_tuples(i):
    "Produces a list of tuples with contiguous ranges in the input list."
    i = sorted(i)
    low_bound = None
    high_bound = None
    for val in i:
        if low_bound is None:
            low_bound = val
            high_bound = val
        else:
            assert(not high_bound is None)
            if val == high_bound + 1:
                high_bound = val
            else:
                yield (low_bound, high_bound)
                low_bound = val
                high_bound = val
    if not low_bound is None:
        yield (low_bound, high_bound)

def build_range_code(var, i):
    "Produces a fragment of code that tests whether the variable name matches values in the given range."
    ranges = build_range_tuples(i)
    result = ""
    for r in ranges:
        if r[0] == r[1]:
            cond = var + " == " + str(r[0])
        else:
            cond = "%d <= %s && %s <= %d" % (r[0], var, var, r[1])
        if result == "":
            result = cond
        else:
            result = result + " || " + cond
    return result

class db_docsref_gen:
    "A generator of reference documentation."
    def __init__(self, db):
        self.db = db
        instrs = [i for i in self.db.instr if i.is_dxil_op]
        instrs = sorted(instrs, key=lambda v : ("" if v.category == None else v.category) + "." + v.name)
        self.instrs = instrs
        val_rules = sorted(db.val_rules, key=lambda v : ("" if v.category == None else v.category) + "." + v.name)
        self.val_rules = val_rules

    def print_content(self):
        self.print_header()
        self.print_body()
        self.print_footer()

    def print_header(self):
        print("<!DOCTYPE html>")
        print("<html><head><title>DXIL Reference</title>")
        print("<style>body { font-family: Verdana; font-size: small; }</style>")
        print("</head><body><h1>DXIL Reference</h1>")
        self.print_toc("Instructions", "i", self.instrs)
        self.print_toc("Rules", "r", self.val_rules)

    def print_body(self):
        self.print_instruction_details()
        self.print_valrule_details()

    def print_instruction_details(self):
        print("<h2>Instruction Details</h2>")
        for i in self.instrs:
            print("<h3><a name='i%s'>%s</a></h3>" % (i.name, i.name))
            print("<div>Opcode: %d. This instruction %s.</div>" % (i.dxil_opid, i.doc))
            if i.remarks:
                # This is likely a .rst fragment, but this will do for now.
                print("<div> " + i.remarks + "</div>")
            print("<div>Operands:</div>")
            print("<ul>")
            for o in i.ops:
                if o.pos == 0:
                    print("<li>result: %s - %s</li>" % (o.llvm_type, o.doc))
                else:
                    enum_desc = "" if o.enum_name == "" else " one of %s: %s" % (o.enum_name, ",".join(db.enum_idx[o.enum_name].value_names()))
                    print("<li>%d - %s: %s%s%s</li>" % (o.pos - 1, o.name, o.llvm_type, "" if o.doc == "" else " - " + o.doc, enum_desc))
            print("</ul>")
            print("<div><a href='#Instructions'>(top)</a></div>")

    def print_valrule_details(self):
        print("<h2>Rule Details</h2>")
        for i in self.val_rules:
            print("<h3><a name='r%s'>%s</a></h3>" % (i.name, i.name))
            print("<div>" + i.doc + "</div>")
            print("<div><a href='#Rules'>(top)</a></div>")

    def print_toc(self, name, aprefix, values):
        print("<h2><a name='" + name + "'>" + name + "</a></h2>")
        last_category = ""
        for i in values:
            if i.category != last_category:
                if last_category != None:
                    print("</ul>")
                print("<div><b>%s</b></div><ul>" % i.category)
                last_category = i.category
            print("<li><a href='#" + aprefix + "%s'>%s</a></li>" % (i.name, i.name))
        print("</ul>")

    def print_footer(self):
        print("</body></html>")


class db_instrhelp_gen:
    "A generator of instruction helper classes."
    def __init__(self, db):
        self.db = db
        TypeInfo = collections.namedtuple("TypeInfo", "name bits")
        self.llvm_type_map = {
            "i1": TypeInfo("bool", 1),
            "i8": TypeInfo("int8_t", 8),
            "u8": TypeInfo("uint8_t", 8),
            "i32": TypeInfo("int32_t", 32),
            "u32": TypeInfo("uint32_t", 32)
            }
        self.IsDxilOpFuncCallInst = "hlsl::OP::IsDxilOpFuncCallInst"

    def print_content(self):
        self.print_header()
        self.print_body()
        self.print_footer()

    def print_header(self):
        print("///////////////////////////////////////////////////////////////////////////////")
        print("//                                                                           //")
        print("// Copyright (C) Microsoft Corporation. All rights reserved.                 //")
        print("// DxilInstructions.h                                                        //")
        print("//                                                                           //")
        print("// This file provides a library of instruction helper classes.               //")
        print("//                                                                           //")
        print("// MUCH WORK YET TO BE DONE - EXPECT THIS WILL CHANGE - GENERATED FILE       //")
        print("//                                                                           //")
        print("///////////////////////////////////////////////////////////////////////////////")
        print("")
        print("// TODO: add correct include directives")
        print("// TODO: add accessors with values")
        print("// TODO: add validation support code, including calling into right fn")
        print("// TODO: add type hierarchy")
        print("namespace hlsl {")

    def bool_lit(self, val):
        return "true" if val else "false";

    def op_type(self, o):
        if o.llvm_type in self.llvm_type_map:
            return self.llvm_type_map[o.llvm_type].name
        raise ValueError("Don't know how to describe type %s for operand %s." % (o.llvm_type, o.name))
    def op_size(self, o):
        if o.llvm_type in self.llvm_type_map:
            return self.llvm_type_map[o.llvm_type].bits
        raise ValueError("Don't know how to describe type %s for operand %s." % (o.llvm_type, o.name))

    def op_const_expr(self, o):
        return "(%s)(llvm::dyn_cast<llvm::ConstantInt>(Instr->getOperand(%d))->getZExtValue())" % (self.op_type(o), o.pos - 1)
    def op_set_const_expr(self, o):
        type_size = self.op_size(o)
        return "llvm::Constant::getIntegerValue(llvm::IntegerType::get(Instr->getContext(), %d), llvm::APInt(%d, (uint64_t)val))" % (type_size, type_size)

    def print_body(self):
        for i in self.db.instr:
            if i.is_reserved: continue
            if i.inst_helper_prefix:
                struct_name = "%s_%s" % (i.inst_helper_prefix, i.name)
            elif i.is_dxil_op:
                struct_name = "DxilInst_%s" % i.name
            else:
                struct_name = "LlvmInst_%s" % i.name
            if i.doc:
                print("/// This instruction %s" % i.doc)
            print("struct %s {" % struct_name)
            print("  llvm::Instruction *Instr;")
            print("  // Construction and identification")
            print("  %s(llvm::Instruction *pInstr) : Instr(pInstr) {}" % struct_name)
            print("  operator bool() const {")
            if i.is_dxil_op:
                op_name = i.fully_qualified_name()
                print("    return %s(Instr, %s);" % (self.IsDxilOpFuncCallInst, op_name))
            else:
                print("    return Instr->getOpcode() == llvm::Instruction::%s;" % i.name)
            print("  }")
            print("  // Validation support")
            print("  bool isAllowed() const { return %s; }" % self.bool_lit(i.is_allowed))
            if i.is_dxil_op:
                print("  bool isArgumentListValid() const {")
                print("    if (%d != llvm::dyn_cast<llvm::CallInst>(Instr)->getNumArgOperands()) return false;" % (len(i.ops) - 1))
                print("    return true;")
                # TODO - check operand types
                print("  }")
                EnumWritten = False
                for o in i.ops:
                    if o.pos > 1: # 0 is return type, 1 is DXIL OP id
                        if not EnumWritten:
                            print("  // Operand indexes")
                            print("  enum OperandIdx {")
                            EnumWritten = True
                        print("    arg_%s = %d," % (o.name, o.pos - 1))
                if EnumWritten:
                    print("  };")
                AccessorsWritten = False
                for o in i.ops:
                    if o.pos > 1: # 0 is return type, 1 is DXIL OP id
                        if not AccessorsWritten:
                            print("  // Accessors")
                            AccessorsWritten = True
                        print("  llvm::Value *get_%s() const { return Instr->getOperand(%d); }" % (o.name, o.pos - 1))
                        print("  void set_%s(llvm::Value *val) { Instr->setOperand(%d, val); }" % (o.name, o.pos - 1))
                        if o.is_const:
                            print("  %s get_%s_val() const { return %s; }" % (self.op_type(o), o.name, self.op_const_expr(o)))
                            print("  void set_%s_val(%s val) { Instr->setOperand(%d, %s); }" % (o.name, self.op_type(o), o.pos - 1, self.op_set_const_expr(o)))
            print("};")
            print("")

    def print_footer(self):
        print("} // namespace hlsl")

class db_enumhelp_gen:
    "A generator of enumeration declarations."
    def __init__(self, db):
        self.db = db
        # Some enums should get a last enum marker.
        self.lastEnumNames = {
            "OpCode": "NumOpCodes",
            "OpCodeClass": "NumOpClasses"
        }

    def print_enum(self, e, **kwargs):
        print("// %s" % e.doc)
        print("enum class %s : unsigned {" % e.name)
        hide_val = kwargs.get("hide_val", False)
        sorted_values = e.values
        if kwargs.get("sort_val", True):
            sorted_values = sorted(e.values, key=lambda v : ("" if v.category == None else v.category) + "." + v.name)
        last_category = None
        for v in sorted_values:
            if v.category != last_category:
                if last_category != None:
                    print("")
                print("  // %s" % v.category)
                last_category = v.category

            line_format = "  {name}"
            if not e.is_internal and not hide_val:
                line_format += " = {value}"
            line_format += ","
            if v.doc:
                line_format += " // {doc}"
            print(line_format.format(name=v.name, value=v.value, doc=v.doc))
        if e.name in self.lastEnumNames:
            lastName = self.lastEnumNames[e.name]
            versioned = ["%s_Dxil_%d_%d = %d," % (lastName, major, minor, info[lastName])
                         for (major, minor), info in sorted(self.db.dxil_version_info.items())
                         if lastName in info]
            if versioned:
                print("")
                for val in versioned:
                    print("  " + val)
            print("")
            print("  " + lastName + " = " + str(len(sorted_values)) + " // exclusive last value of enumeration")
        print("};")

    def print_content(self):
        for e in sorted(self.db.enums, key=lambda e : e.name):
            self.print_enum(e)

class db_oload_gen:
    "A generator of overload tables."
    def __init__(self, db):
        self.db = db
        instrs = [i for i in self.db.instr if i.is_dxil_op]
        self.instrs = sorted(instrs, key=lambda i : i.dxil_opid)

    def print_content(self):
        self.print_opfunc_props()
        print("...")
        self.print_opfunc_table()

    def print_opfunc_props(self):
        print("const OP::OpCodeProperty OP::m_OpCodeProps[(unsigned)OP::OpCode::NumOpCodes] = {")
        print("//   OpCode                       OpCode name,                OpCodeClass                    OpCodeClass name,              void,     h,     f,     d,    i1,    i8,   i16,   i32,   i64  function attribute")
        # Example formatted string:
        #   {  OC::TempRegLoad,             "TempRegLoad",              OCC::TempRegLoad,              "tempRegLoad",                false,  true,  true, false,  true, false,  true,  true, false, Attribute::ReadOnly, },
        # 012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
        # 0         1         2         3         4         5         6         7         8         9         0         1         2         3         4         5         6         7         8         9         0

        last_category = None
        # overload types are a string of (v)oid, (h)alf, (f)loat, (d)ouble, (1)-bit, (8)-bit, (w)ord, (i)nt, (l)ong
        f = lambda i,c : "true," if i.oload_types.find(c) >= 0 else "false,"
        lower_exceptions = { "CBufferLoad" : "cbufferLoad", "CBufferLoadLegacy" : "cbufferLoadLegacy", "GSInstanceID" : "gsInstanceID" }
        lower_fn = lambda t: lower_exceptions[t] if t in lower_exceptions else t[:1].lower() + t[1:]
        attr_dict = { "": "None", "ro": "ReadOnly", "rn": "ReadNone", "nd": "NoDuplicate" }
        attr_fn = lambda i : "Attribute::" + attr_dict[i.fn_attr] + ","
        for i in self.instrs:
            if last_category != i.category:
                if last_category != None:
                    print("")
                print("  // {category:118} void,     h,     f,     d,    i1,    i8,   i16,   i32,   i64  function attribute".format(category=i.category))
                last_category = i.category
            print("  {{  OC::{name:24} {quotName:27} OCC::{className:25} {classNameQuot:28} {v:>7}{h:>7}{f:>7}{d:>7}{b:>7}{e:>7}{w:>7}{i:>7}{l:>7} {attr:20} }},".format(
                name=i.name+",", quotName='"'+i.name+'",', className=i.dxil_class+",", classNameQuot='"'+lower_fn(i.dxil_class)+'",',
                v=f(i,"v"), h=f(i,"h"), f=f(i,"f"), d=f(i,"d"), b=f(i,"1"), e=f(i,"8"), w=f(i,"w"), i=f(i,"i"), l=f(i,"l"), attr=attr_fn(i)))
        print("};")

    def print_opfunc_table(self):
        # Print the table for OP::GetOpFunc
        op_type_texts = {
            "$cb": "CBRT(pETy);",
            "$o": "A(pETy);",
            "$r": "RRT(pETy);",
            "d": "A(pF64);",
            "dims": "A(pDim);",
            "f": "A(pF32);",
            "h": "A(pF16);",
            "i1": "A(pI1);",
            "i16": "A(pI16);",
            "i32": "A(pI32);",
            "i32c": "A(pI32C);",
            "i64": "A(pI64);",
            "i8": "A(pI8);",
            "$u4": "A(pI4S);",
            "pf32": "A(pPF32);",
            "res": "A(pRes);",
            "splitdouble": "A(pSDT);",
            "twoi32": "A(p2I32);",
            "twof32": "A(p2F32);",
            "fouri32": "A(p4I32);",
            "fourf32": "A(p4F32);",
            "u32": "A(pI32);",
            "u64": "A(pI64);",
            "u8": "A(pI8);",
            "v": "A(pV);",
            "w": "A(pWav);",
            "SamplePos": "A(pPos);",
        }
        last_category = None
        for i in self.instrs:
            if last_category != i.category:
                if last_category != None:
                    print("")
                print("    // %s" % i.category)
                last_category = i.category
            line = "  case OpCode::{name:24}".format(name = i.name + ":")
            for index, o in enumerate(i.ops):
                assert o.llvm_type in op_type_texts, "llvm type %s in instruction %s is unknown" % (o.llvm_type, i.name)
                op_type_text = op_type_texts[o.llvm_type]
                if index == 0:
                    line = line + "{val:13}".format(val=op_type_text)
                else:
                    line = line + "{val:9}".format(val=op_type_text)
            line = line + "break;"
            print(line)

    def print_opfunc_oload_type(self):
        # Print the function for OP::GetOverloadType
        elt_ty = "$o"
        res_ret_ty = "$r"
        cb_ret_ty = "$cb"

        last_category = None

        index_dict = collections.OrderedDict()
        single_dict = collections.OrderedDict()
        struct_list = []

        for instr in self.instrs:
            ret_ty = instr.ops[0].llvm_type
            # Skip case return type is overload type
            if (ret_ty == elt_ty):
                continue

            if ret_ty == res_ret_ty:
                struct_list.append(instr.name)
                continue

            if ret_ty == cb_ret_ty:
                struct_list.append(instr.name)
                continue

            in_param_ty = False
            # Try to find elt_ty in parameter types.
            for index, op in enumerate(instr.ops):
                # Skip return type.
                if (op.pos == 0):
                    continue
                # Skip dxil opcode.
                if (op.pos == 1):
                    continue

                op_type = op.llvm_type
                if (op_type == elt_ty):
                    # Skip return op
                    index = index - 1
                    if index not in index_dict:
                        index_dict[index] = [instr.name]
                    else:
                        index_dict[index].append(instr.name)
                    in_param_ty = True
                    break

            if in_param_ty:
                continue

            # No overload, just return the single oload_type.
            assert len(instr.oload_types)==1, "overload no elt_ty %s" % (instr.name)
            ty = instr.oload_types[0]
            type_code_texts = {
            "d": "Type::getDoubleTy(m_Ctx)",
            "f": "Type::getFloatTy(m_Ctx)",
            "h": "Type::getHalfTy",
            "1": "IntegerType::get(m_Ctx, 1)",
			"8": "IntegerType::get(m_Ctx, 8)",
            "w": "IntegerType::get(m_Ctx, 16)",
            "i": "IntegerType::get(m_Ctx, 32)",
            "l": "IntegerType::get(m_Ctx, 64)",
            "v": "Type::getVoidTy(m_Ctx)",
            }
            assert ty in type_code_texts, "llvm type %s is unknown" % (ty)
            ty_code = type_code_texts[ty]

            if ty_code not in single_dict:
                single_dict[ty_code] = [instr.name]
            else:
                single_dict[ty_code].append(instr.name)

        for index, opcodes in index_dict.items():
            line = ""
            for opcode in opcodes:
                line = line + "case OpCode::{name}".format(name = opcode + ":\n")

            line = line + "  DXASSERT_NOMSG(FT->getNumParams() > " + str(index) + ");\n"
            line = line + "  return FT->getParamType(" + str(index) + ");"
            print(line)

        for code, opcodes in single_dict.items():
            line = ""
            for opcode in opcodes:
                line = line + "case OpCode::{name}".format(name = opcode + ":\n")
            line = line + "  return " + code + ";"
            print(line)

        line = ""
        for opcode in struct_list:
            line = line + "case OpCode::{name}".format(name = opcode + ":\n")
        line = line + "{\n"
        line = line + "  StructType *ST = cast<StructType>(Ty);\n"
        line = line + "  return ST->getElementType(0);\n"
        line = line + "}"
        print(line)


class db_valfns_gen:
    "A generator of validation functions."
    def __init__(self, db):
        self.db = db

    def print_content(self):
        self.print_header()
        self.print_body()

    def print_header(self):
        print("///////////////////////////////////////////////////////////////////////////////")
        print("// Instruction validation functions.                                         //")

    def bool_lit(self, val):
        return "true" if val else "false";

    def op_type(self, o):
        if o.llvm_type == "i8":
            return "int8_t"
        if o.llvm_type == "u8":
            return "uint8_t"
        raise ValueError("Don't know how to describe type %s for operand %s." % (o.llvm_type, o.name))

    def op_const_expr(self, o):
        if o.llvm_type == "i8" or o.llvm_type == "u8":
            return "(%s)(llvm::dyn_cast<llvm::ConstantInt>(Instr->getOperand(%d))->getZExtValue())" % (self.op_type(o), o.pos - 1)
        raise ValueError("Don't know how to describe type %s for operand %s." % (o.llvm_type, o.name))

    def print_body(self):
        llvm_instrs = [i for i in self.db.instr if i.is_allowed and not i.is_dxil_op]
        print("static bool IsLLVMInstructionAllowed(llvm::Instruction &I) {")
        self.print_comment("  // ", "Allow: %s" % ", ".join([i.name + "=" + str(i.llvm_id) for i in llvm_instrs]))
        print("  unsigned op = I.getOpcode();")
        print("  return %s;" % build_range_code("op", [i.llvm_id for i in llvm_instrs]))
        print("}")
        print("")

    def print_comment(self, prefix, val):
        print(format_comment(prefix, val))

class macro_table_gen:
    "A generator for macro tables."

    def format_row(self, row, widths, sep=', '):
        frow = [str(item) + sep + (' ' * (width - len(item)))
                for item, width in list(zip(row, widths))[:-1]] + [str(row[-1])]
        return ''.join(frow)

    def format_table(self, table, *args, **kwargs):
        widths = [  functools.reduce(max, [   len(row[i])
                                    for row in table], 1)
                    for i in range(len(table[0]))]
        formatted = []
        for row in table:
            formatted.append(self.format_row(row, widths, *args, **kwargs))
        return formatted

    def print_table(self, table, macro_name):
        formatted = self.format_table(table)
        print(  '//   %s\n' % formatted[0] +
                '#define %s(DO) \\\n' % macro_name +
                ' \\\n'.join(['  DO(%s)' % frow for frow in formatted[1:]]))

class db_sigpoint_gen(macro_table_gen):
    "A generator for SigPoint tables."
    def __init__(self, db):
        self.db = db

    def print_sigpoint_table(self):
        self.print_table(self.db.sigpoint_table, 'DO_SIGPOINTS')

    def print_interpretation_table(self):
        self.print_table(self.db.interpretation_table, 'DO_INTERPRETATION_TABLE')

    def print_content(self):
        self.print_sigpoint_table()
        self.print_interpretation_table()

class string_output:
    def __init__(self):
        self.val = ""
    def write(self, text):
        self.val = self.val + str(text)
    def __str__(self):
        return self.val

def run_with_stdout(fn):
    import sys
    _stdout_saved = sys.stdout
    so = string_output()
    try:
        sys.stdout = so
        fn()
    finally:
        sys.stdout = _stdout_saved
    return str(so)

def get_hlsl_intrinsic_stats():
    db = get_db_hlsl()
    longest_fn = db.intrinsics[0]
    longest_param = None
    longest_arglist_fn = db.intrinsics[0]
    for i in sorted(db.intrinsics, key=lambda x: x.key):
        # Get some values for maximum lengths.
        if len(i.name) > len(longest_fn.name):
            longest_fn = i
        for p_idx, p in enumerate(i.params):
            if p_idx > 0 and (longest_param is None or len(p.name) > len(longest_param.name)):
                longest_param = p
        if len(i.params) > len(longest_arglist_fn.params):
            longest_arglist_fn = i
    result = ""
    for k in sorted(db.namespaces.keys()):
        v = db.namespaces[k]
        result += "static const UINT g_u%sCount = %d;\n" % (k, len(v.intrinsics))
    result += "\n"
    result += "static const int g_MaxIntrinsicName = %d; // Count of characters for longest intrinsic name - '%s'\n" % (len(longest_fn.name), longest_fn.name)
    result += "static const int g_MaxIntrinsicParamName = %d; // Count of characters for longest intrinsic parameter name - '%s'\n" % (len(longest_param.name), longest_param.name)
    result += "static const int g_MaxIntrinsicParamCount = %d; // Count of parameters (without return) for longest intrinsic argument list - '%s'\n" % (len(longest_arglist_fn.params) - 1, longest_arglist_fn.name)
    return result

def get_hlsl_intrinsics():
    db = get_db_hlsl()
    result = ""
    last_ns = ""
    ns_table = ""
    is_vk_table = False  # SPIRV Change
    id_prefix = ""
    arg_idx = 0
    opcode_namespace = db.opcode_namespace
    for i in sorted(db.intrinsics, key=lambda x: x.key):
        if last_ns != i.ns:
            last_ns = i.ns
            id_prefix = "IOP" if last_ns == "Intrinsics" else "MOP"
            if (len(ns_table)):
                result += ns_table + "};\n"
                # SPIRV Change Starts
                if is_vk_table:
                    result += "\n#endif // ENABLE_SPIRV_CODEGEN\n"
                    is_vk_table = False
                # SPIRV Change Ends
            result += "\n//\n// Start of %s\n//\n\n" % (last_ns)
            # This used to be qualified as __declspec(selectany), but that's no longer necessary.
            ns_table = "static const HLSL_INTRINSIC g_%s[] =\n{\n" % (last_ns)
            # SPIRV Change Starts
            if (i.vulkanSpecific):
                is_vk_table = True
                result += "#ifdef ENABLE_SPIRV_CODEGEN\n\n"
            # SPIRV Change Ends
            arg_idx = 0
        ns_table += "    {(UINT)%s::%s_%s, %s, %s, %d, %d, g_%s_Args%s},\n" % (opcode_namespace, id_prefix, i.name, str(i.readonly).lower(), str(i.readnone).lower(), i.overload_param_index,len(i.params), last_ns, arg_idx)
        result += "static const HLSL_INTRINSIC_ARGUMENT g_%s_Args%s[] =\n{\n" % (last_ns, arg_idx)
        for p in i.params:
            result += "    {\"%s\", %s, %s, %s, %s, %s, %s, %s},\n" % (
                p.name, p.param_qual, p.template_id, p.template_list,
                p.component_id, p.component_list, p.rows, p.cols)
        result += "};\n\n"
        arg_idx += 1
    result += ns_table + "};\n"
    result += "\n#endif // ENABLE_SPIRV_CODEGEN\n" if is_vk_table else ""  # SPIRV Change
    return result

# SPIRV Change Starts
def wrap_with_ifdef_if_vulkan_specific(intrinsic, text):
    if intrinsic.vulkanSpecific:
        return "#ifdef ENABLE_SPIRV_CODEGEN\n" + text + "#endif // ENABLE_SPIRV_CODEGEN\n"
    return text
# SPIRV Change Ends

def enum_hlsl_intrinsics():
    db = get_db_hlsl()
    result = ""
    enumed = []
    for i in sorted(db.intrinsics, key=lambda x: x.key):
        if (i.enum_name not in enumed):
            enumerant = "  %s,\n" % (i.enum_name)
            result += wrap_with_ifdef_if_vulkan_specific(i, enumerant)  # SPIRV Change
            enumed.append(i.enum_name)
    # unsigned
    result += "  // unsigned\n"

    for i in sorted(db.intrinsics, key=lambda x: x.key):
        if (i.unsigned_op != ""):
          if (i.unsigned_op not in enumed):
            result += "  %s,\n" % (i.unsigned_op)
            enumed.append(i.unsigned_op)

    result += "  Num_Intrinsics,\n"
    return result

def has_unsigned_hlsl_intrinsics():
    db = get_db_hlsl()
    result = ""
    enumed = []
    # unsigned
    for i in sorted(db.intrinsics, key=lambda x: x.key):
        if (i.unsigned_op != ""):
          if (i.enum_name not in enumed):
            result += "  case IntrinsicOp::%s:\n" % (i.enum_name)
            enumed.append(i.enum_name)
    return result

def get_unsigned_hlsl_intrinsics():
    db = get_db_hlsl()
    result = ""
    enumed = []
    # unsigned
    for i in sorted(db.intrinsics, key=lambda x: x.key):
        if (i.unsigned_op != ""):
          if (i.enum_name not in enumed):
            enumed.append(i.enum_name)
            result += "  case IntrinsicOp::%s:\n" % (i.enum_name)
            result += "    return static_cast<unsigned>(IntrinsicOp::%s);\n" % (i.unsigned_op)
    return result

def get_oloads_props():
    db = get_db_dxil()
    gen = db_oload_gen(db)
    return run_with_stdout(lambda: gen.print_opfunc_props())

def get_oloads_funcs():
    db = get_db_dxil()
    gen = db_oload_gen(db)
    return run_with_stdout(lambda: gen.print_opfunc_table())

def get_funcs_oload_type():
    db = get_db_dxil()
    gen = db_oload_gen(db)
    return run_with_stdout(lambda: gen.print_opfunc_oload_type())

def get_enum_decl(name, **kwargs):
    db = get_db_dxil()
    gen = db_enumhelp_gen(db)
    return run_with_stdout(lambda: gen.print_enum(db.enum_idx[name], **kwargs))

def get_valrule_enum():
    return get_enum_decl("ValidationRule", hide_val=True)

def get_valrule_text():
    db = get_db_dxil()
    result = "switch(value) {\n"
    for v in db.enum_idx["ValidationRule"].values:
        result += "  case hlsl::ValidationRule::" + v.name + ": return \"" + v.err_msg + "\";\n"
    result += "}\n"
    return result

def get_instrhelper():
    db = get_db_dxil()
    gen = db_instrhelp_gen(db)
    return run_with_stdout(lambda: gen.print_body())

def get_instrs_pred(varname, pred, attr_name="dxil_opid"):
    db = get_db_dxil()
    if type(pred) == str:
        pred_fn = lambda i: getattr(i, pred)
    else:
        pred_fn = pred
    llvm_instrs = [i for i in db.instr if pred_fn(i)]
    result = format_comment("// ", "Instructions: %s" % ", ".join([i.name + "=" + str(getattr(i, attr_name)) for i in llvm_instrs]))
    result += "return %s;" % build_range_code(varname, [getattr(i, attr_name) for i in llvm_instrs])
    result += "\n"
    return result

def get_instrs_rst():
    "Create an rst table of allowed LLVM instructions."
    db = get_db_dxil()
    instrs = [i for i in db.instr if i.is_allowed and not i.is_dxil_op]
    instrs = sorted(instrs, key=lambda v : v.llvm_id)
    rows = []
    rows.append(["Instruction", "Action", "Operand overloads"])
    for i in instrs:
        rows.append([i.name, i.doc, i.oload_types])
    result = "\n\n" + format_rst_table(rows) + "\n\n"
    # Add detailed instruction information where available.
    for i in instrs:
        if i.remarks:
            result += i.name + "\n" + ("~" * len(i.name)) + "\n\n" + i.remarks + "\n\n"
    return result + "\n"

def get_init_passes():
    "Create a series of statements to initialize passes in a registry."
    db = get_db_dxil()
    result = ""
    for p in sorted(db.passes, key=lambda p : p.type_name):
        result += "initialize%sPass(Registry);\n" % p.type_name
    return result

def get_pass_arg_names():
    "Return an ArrayRef of argument names based on passName"
    db = get_db_dxil()
    decl_result = ""
    check_result = ""
    for p in sorted(db.passes, key=lambda p : p.type_name):
        if len(p.args):
            decl_result += "static const LPCSTR %sArgs[] = { " % p.type_name
            check_result += "if (strcmp(passName, \"%s\") == 0) return ArrayRef<LPCSTR>(%sArgs, _countof(%sArgs));\n" % (p.name, p.type_name, p.type_name)
            sep = ""
            for a in p.args:
                decl_result += sep + "\"%s\"" % a.name
                sep = ", "
            decl_result += " };\n"
    return decl_result + check_result

def get_pass_arg_descs():
    "Return an ArrayRef of argument descriptions based on passName"
    db = get_db_dxil()
    decl_result = ""
    check_result = ""
    for p in sorted(db.passes, key=lambda p : p.type_name):
        if len(p.args):
            decl_result += "static const LPCSTR %sArgs[] = { " % p.type_name
            check_result += "if (strcmp(passName, \"%s\") == 0) return ArrayRef<LPCSTR>(%sArgs, _countof(%sArgs));\n" % (p.name, p.type_name, p.type_name)
            sep = ""
            for a in p.args:
                decl_result += sep + "\"%s\"" % a.doc
                sep = ", "
            decl_result += " };\n"
    return decl_result + check_result

def get_is_pass_option_name():
    "Create a return expression to check whether a value 'S' is a pass option name."
    db = get_db_dxil()
    prefix = ""
    result = "return "
    for k in sorted(db.pass_idx_args):
        result += prefix + "S.equals(\"%s\")" % k
        prefix = "\n  ||  "
    return result + ";"

def get_opcodes_rst():
    "Create an rst table of opcodes"
    db = get_db_dxil()
    instrs = [i for i in db.instr if i.is_allowed and i.is_dxil_op]
    instrs = sorted(instrs, key=lambda v : v.dxil_opid)
    rows = []
    rows.append(["ID", "Name", "Description"])
    for i in instrs:
        op_name = i.dxil_op
        if i.remarks:
            op_name = op_name + "_" # append _ to enable internal hyperlink on rst files
        rows.append([i.dxil_opid, op_name, i.doc])
    result = "\n\n" + format_rst_table(rows) + "\n\n"
    # Add detailed instruction information where available.
    instrs = sorted(instrs, key=lambda v : v.name)
    for i in instrs:
        if i.remarks:
            result += i.name + "\n" + ("~" * len(i.name)) + "\n\n" + i.remarks + "\n\n"
    return result + "\n"

def get_valrules_rst():
    "Create an rst table of validation rules instructions."
    db = get_db_dxil()
    rules = [i for i in db.val_rules if not i.is_disabled]
    rules = sorted(rules, key=lambda v : v.name)
    rows = []
    rows.append(["Rule Code", "Description"])
    for i in rules:
        rows.append([i.name, i.doc])
    return "\n\n" + format_rst_table(rows) + "\n\n"

def get_opsigs():
    # Create a list of DXIL operation signatures, sorted by ID.
    db = get_db_dxil()
    instrs = [i for i in db.instr if i.is_dxil_op]
    instrs = sorted(instrs, key=lambda v : v.dxil_opid)
    # db_dxil already asserts that the numbering is dense.
    # Create the code to write out.
    code = "static const char *OpCodeSignatures[] = {\n"
    for inst_idx,i in enumerate(instrs):
        code += "  \"("
        for operand in i.ops:
            if operand.pos > 1: # skip 0 (the return value) and 1 (the opcode itself)
                code += operand.name
                if operand.pos < len(i.ops) - 1:
                    code += ","
        code += ")\""
        if inst_idx < len(instrs) - 1:
            code += ","
        code += "  // " + i.name
        code += "\n"
    code += "};\n"
    return code

def get_valopcode_sm_text():
    db = get_db_dxil()
    instrs = [i for i in db.instr if i.is_dxil_op]
    instrs = sorted(instrs, key=lambda v : (v.shader_model, v.shader_stages, v.dxil_opid))
    last_model = None
    last_stage = None
    grouped_instrs = []
    code = ""
    def flush_instrs(grouped_instrs, last_model, last_stage):
        if len(grouped_instrs) == 0:
            return ""
        result = format_comment("// ", "Instructions: %s" % ", ".join([i.name + "=" + str(i.dxil_opid) for i in grouped_instrs]))
        result += "if (" + build_range_code("op", [i.dxil_opid for i in grouped_instrs]) + ")\n"
        result += "  return "

        model_cond = stage_cond = None
        if last_model != (6,0):
            model_cond = "pSM->GetMajor() > %d || (pSM->GetMajor() == %d && pSM->GetMinor() >= %d)" % (
                last_model[0], last_model[0], last_model[1])
        if last_stage != "*":
            stage_cond = ' || '.join(["pSM->Is%sS()" % c.upper() for c in last_stage])
        if model_cond or stage_cond:
            result += '\n      && '.join(
                ["(%s)" % expr for expr in (model_cond, stage_cond) if expr] )
            return result + ";\n"
        else:
            # don't write these out, instead fall through
            return ""

    for i in instrs:
        if (i.shader_model, i.shader_stages) != (last_model, last_stage):
            code += flush_instrs(grouped_instrs, last_model, last_stage)
            grouped_instrs = []
            last_model = i.shader_model
            last_stage = i.shader_stages
        grouped_instrs.append(i)
    code += flush_instrs(grouped_instrs, last_model, last_stage)
    code += "return true;\n"
    return code

def get_sigpoint_table():
    db = get_db_dxil()
    gen = db_sigpoint_gen(db)
    return run_with_stdout(lambda: gen.print_sigpoint_table())

def get_sigpoint_rst():
    "Create an rst table for SigPointKind."
    db = get_db_dxil()
    rows = [row[:] for row in db.sigpoint_table[:-1]]   # Copy table
    e = dict([(v.name, v) for v in db.enum_idx['SigPointKind'].values])
    rows[0] = ['ID'] + rows[0] + ['Description']
    for i in range(1, len(rows)):
        row = rows[i]
        v = e[row[0]]
        rows[i] = [v.value] + row + [v.doc]
    return "\n\n" + format_rst_table(rows) + "\n\n"

def get_sem_interpretation_enum_rst():
    db = get_db_dxil()
    rows = ([['ID', 'Name', 'Description']] +
            [[v.value, v.name, v.doc]
             for v in db.enum_idx['SemanticInterpretationKind'].values[:-1]])
    return "\n\n" + format_rst_table(rows) + "\n\n"

def get_sem_interpretation_table_rst():
    db = get_db_dxil()
    return "\n\n" + format_rst_table(db.interpretation_table) + "\n\n"

def get_interpretation_table():
    db = get_db_dxil()
    gen = db_sigpoint_gen(db)
    return run_with_stdout(lambda: gen.print_interpretation_table())


def RunCodeTagUpdate(file_path):
    import os
    import CodeTags
    print(" ... updating " + file_path)
    args = [file_path, file_path + ".tmp"]
    result = CodeTags.main(args)
    if result != 0:
        print(" ... error: %d" % result)
    else:
        with open(file_path, 'rt') as f:
            before = f.read()
        with open(file_path + ".tmp", 'rt') as f:
            after = f.read()
        if before == after:
            print("  --- no changes found")
        else:
            print("  +++ changes found, updating file")
            with open(file_path, 'wt') as f:
                f.write(after)
        os.remove(file_path + ".tmp")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Generate code to handle instructions.")
    parser.add_argument("-gen", choices=["docs-ref", "docs-spec", "inst-header", "enums", "oloads", "valfns"], help="Output type to generate.")
    parser.add_argument("-update-files", action="store_const", const=True)
    args = parser.parse_args()

    db = get_db_dxil() # used by all generators, also handy to have it run validation

    if args.gen == "docs-ref":
        gen = db_docsref_gen(db)
        gen.print_content()

    if args.gen == "docs-spec":
        import os, docutils.core
        assert "HLSL_SRC_DIR" in os.environ, "Environment variable HLSL_SRC_DIR is not defined"
        hlsl_src_dir = os.environ["HLSL_SRC_DIR"]
        spec_file = os.path.abspath(os.path.join(hlsl_src_dir, "docs/DXIL.rst"))
        with open(spec_file) as f:
            s = docutils.core.publish_file(f, writer_name="html")

    if args.gen == "inst-header":
        gen = db_instrhelp_gen(db)
        gen.print_content()

    if args.gen == "enums":
        gen = db_enumhelp_gen(db)
        gen.print_content()

    if args.gen == "oloads":
        gen = db_oload_gen(db)
        gen.print_content()

    if args.gen == "valfns":
        gen = db_valfns_gen(db)
        gen.print_content()

    if args.update_files:
        print("Updating files ...")
        import CodeTags
        import os

        assert "HLSL_SRC_DIR" in os.environ, "Environment variable HLSL_SRC_DIR is not defined"
        hlsl_src_dir = os.environ["HLSL_SRC_DIR"]
        pj = lambda *parts: os.path.abspath(os.path.join(*parts))
        files = [
            'docs/DXIL.rst',
            'lib/HLSL/DXILOperations.cpp',
            'include/dxc/HLSL/DXILConstants.h',
            'include/dxc/HLSL/DxilValidation.h',
            'include/dxc/HLSL/DxilInstructions.h',
            'lib/HLSL/DxcOptimizer.cpp',
            'lib/HLSL/DxilValidation.cpp',
            'tools/clang/lib/Sema/gen_intrin_main_tables_15.h',
            'include/dxc/HlslIntrinsicOp.h',
            'tools/clang/tools/dxcompiler/dxcdisassembler.cpp',
            'include/dxc/HLSL/DxilSigPoint.inl',
            ]
        for relative_file_path in files:
            RunCodeTagUpdate(pj(hlsl_src_dir, relative_file_path))