| # Copyright (C) Microsoft Corporation. All rights reserved. |
| # This file is distributed under the University of Illinois Open Source License. See LICENSE.TXT for details. |
| """hcttest-system-values.py - Test all system values with each signature point through fxc. |
| Builds csv tables for the results for each shader model from 4.0 through 5.1. |
| """ |
| import re |
| |
| SignaturePoints = [ |
| # sig point, stage, tessfactors already present |
| ("VSIn", "vs", False), |
| ("VSOut", "vs", False), |
| ("PCIn", "hs", False), |
| ("HSIn", "hs", False), |
| ("HSCPIn", "hs", False), |
| ("HSCPOut", "hs", False), |
| ("PCOut", "hs", True), |
| ("DSIn", "ds", True), |
| ("DSCPIn", "ds", False), |
| ("DSOut", "ds", False), |
| ("GSVIn", "gs", False), |
| ("GSIn", "gs", False), |
| ("GSOut", "gs", False), |
| ("PSIn", "ps", False), |
| ("PSOut", "ps", False), |
| ("CSIn", "cs", False), |
| ] |
| |
| SysValues = """ |
| VertexID |
| InstanceID |
| Position |
| RenderTargetArrayIndex |
| ViewportArrayIndex |
| ClipDistance |
| CullDistance |
| OutputControlPointID |
| DomainLocation |
| PrimitiveID |
| GSInstanceID |
| SampleIndex |
| IsFrontFace |
| Coverage |
| InnerCoverage |
| Target |
| Depth |
| DepthLessEqual |
| DepthGreaterEqual |
| StencilRef |
| DispatchThreadID |
| GroupID |
| GroupIndex |
| GroupThreadID |
| TessFactor |
| InsideTessFactor |
| """.split() |
| |
| |
| def run(cmd, output_filename=None): |
| import os |
| |
| print(cmd) |
| if output_filename: |
| if os.path.isfile(output_filename): |
| os.unlink(output_filename) |
| with file(output_filename, "wt") as f: |
| f.write("%s\n\n" % cmd) |
| ret = os.system(cmd + ' >> "%s" 2>&1' % output_filename) |
| output = "" |
| if os.path.isfile(output_filename): |
| with open(output_filename, "rt") as f: |
| output = f.read() |
| return ret, output |
| else: |
| ret = os.system(cmd) |
| return ret, None |
| |
| |
| sig_examples = """ |
| // Patch Constant signature: |
| // |
| // Name Index Mask Register SysValue Format Used |
| // -------------------- ----- ------ -------- -------- ------- ------ |
| // Arb 0 x 0 NONE float x |
| // SV_TessFactor 0 x 1 QUADEDGE float x |
| // SV_TessFactor 1 x 2 QUADEDGE float x |
| // SV_TessFactor 2 x 3 QUADEDGE float x |
| // SV_TessFactor 3 x 4 QUADEDGE float x |
| // SV_InsideTessFactor 0 x 5 QUADINT float x |
| // SV_InsideTessFactor 1 x 6 QUADINT float x |
| // |
| // |
| // Input signature: |
| // |
| // Name Index Mask Register SysValue Format Used |
| // -------------------- ----- ------ -------- -------- ------- ------ |
| // Arb 0 x 0 NONE float |
| // |
| // |
| // Output signature: |
| // |
| // Name Index Mask Register SysValue Format Used |
| // -------------------- ----- ------ -------- -------- ------- ------ |
| // Arb 0 x 0 NONE float x |
| """ |
| |
| rxSigBegin = re.compile(r"^// (Input|Output|Patch Constant) signature:\s*$") |
| rxSigElementsBegin = re.compile( |
| r"^// -------------------- ----- ------ -------- -------- ------- ------\s*$" |
| ) |
| |
| # // SV_Target 1 xyzw 1 TARGET float xyzw |
| rxSigElement = re.compile( |
| r"^// ([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+([^\s]+)\s*([^\s]+)?\s*$" |
| ) |
| # Name, Index, Mask, Register, SysValue, Format, Used = m.groups() |
| |
| |
| # For now, ParseSigs just looks for a matching semantic name and reports whether it uses |
| # a separate register (unpacked) and whether it's treated as arbitrary. |
| def ParseSigs(text, semantic): |
| "return separate_reg, as_arb for matching semantic" |
| it = iter(text.splitlines()) |
| sigtype = None |
| try: |
| while True: |
| line = it.next() |
| m = rxSigBegin.match(line) |
| if m: |
| sigtype = m.group(1) |
| continue |
| m = rxSigElementsBegin.match(line) |
| if m: |
| while True: |
| line = it.next() |
| m = rxSigElement.match(line) |
| if m: |
| Name, Index, Mask, Register, SysValue, Format, Used = m.groups() |
| if Name.lower() == semantic.lower(): |
| try: |
| regnum = int(Register) |
| reg = False |
| except: |
| reg = True |
| arb = SysValue == "NONE" |
| return reg, arb |
| except StopIteration: |
| pass |
| return None |
| |
| |
| # Internal error or validation error: |
| rxInternalError = re.compile(r"^(internal error:.*|error X8000:.*)$") |
| |
| # error X4502: invalid ps input semantic 'Foo' |
| # error X4502: SV_Coverage input not supported on ps_4_0 |
| # error X4502: SV_SampleIndex isn't supported on ps_4_0 |
| # error X3514: SV_GSInstanceID is an invalid input semantic for geometry shader primitives, it must be its own parameter. |
| # error X3514: 'GSMain': input parameter 'tfactor' must have a geometry specifier |
| # also errors for unsupported shader models |
| # error X3660: cs_4_0 does not support interlocked operations |
| rxSemanticErrors = [ |
| re.compile(r".*?\.hlsl.*?: error X4502: invalid .*? semantic '(\w+)'"), |
| re.compile(r".*?\.hlsl.*?: error X4502: (\w+) .*? supported on \w+"), |
| re.compile( |
| r".*?\.hlsl.*?: error X3514: (\w+) is an invalid input semantic for geometry shader primitives, it must be its own parameter\." |
| ), |
| re.compile( |
| r".*?\.hlsl.*?: error X3514: 'GSMain': input parameter '\w+' must have a geometry specifier" |
| ), |
| ] |
| |
| |
| def map_gen(fn, *sequences): |
| "generator style map" |
| iters = map(iter, sequences) |
| while True: |
| yield fn(*map(next, iters)) |
| |
| |
| def firstTrue(iterable): |
| "returns first non-False element, or None." |
| for it in iterable: |
| if it: |
| return it |
| |
| |
| def ParseSVError(text, semantic): |
| "return true if error is about illegal use of matching semantic" |
| for line in text.splitlines(): |
| m = firstTrue(map_gen(lambda rx: rx.match(line), rxSemanticErrors)) |
| if m: |
| if len(m.groups()) < 1 or m.group(1).lower() == semantic.lower(): |
| return True |
| else: |
| m = rxInternalError.match(line) |
| if m: |
| print("#### Internal error detected!") |
| print(m.group(1)) |
| return "InternalError" |
| return False |
| |
| |
| # TODO: Fill in the correct error pattern |
| # error X4576: Non system-generated input signature parameter (Arb) cannot appear after a system generated value. |
| rxMustBeLastError = re.compile( |
| r".*?\.hlsl.*?: error X4576: Non system-generated input signature parameter \(\w+\) cannot appear after a system generated value." |
| ) |
| |
| |
| def ParseSGVError(text, semantic): |
| "return true if error is about matching semantic having to be declared last" |
| for line in text.splitlines(): |
| m = rxMustBeLastError.match(line) |
| if m: |
| return True |
| else: |
| m = rxInternalError.match(line) |
| if m: |
| print("#### Internal error detected!") |
| print(m.group(1)) |
| return "InternalError" |
| return False |
| |
| |
| hlsl_filename = os.abspath( |
| os.path.join( |
| os.environ["HLSL_SRC_DIR"], r"tools\clang\test\HLSL", "system-values.hlsl" |
| ) |
| ) |
| |
| |
| def main(): |
| do("5_1") |
| do("5_0") |
| do("4_1") |
| do("4_0") |
| |
| |
| def do(sm): |
| import os, sys |
| |
| # set up table: |
| table = [[None] * len(SignaturePoints) for sv in SysValues] |
| null_filename = "output\\test_sv_null.txt" |
| |
| for col, (sigpoint, stage, tfpresent) in enumerate(SignaturePoints): |
| entry = stage.upper() + "Main" |
| target = stage + "_%s" % sm |
| |
| # test arb support: |
| ret, output = run( |
| "fxc %s /E %s /T %s /D%s_Defs=Def_Arb(float,Arb1,Arb1)" |
| % (hlsl_filename, entry, target, sigpoint), |
| null_filename, |
| ) |
| arb_supported = ret == 0 |
| |
| # iterate all system values |
| sysvalues = tfpresent and SysValues[:-2] or SysValues |
| for row, sv in enumerate(sysvalues): |
| output_filename = "output\\test_sv_output_%s_%s_%s.txt" % (sm, sv, sigpoint) |
| separate_reg, as_arb, def_last, result = False, False, False, "NotInSig" |
| |
| ret, output = run( |
| "fxc %s /E %s /T %s /D%s_Defs=Def_%s" |
| % (hlsl_filename, entry, target, sigpoint, sv), |
| output_filename, |
| ) |
| if ret: |
| # Failed, look for expected error message: |
| found = ParseSVError(output, "SV_" + sv) |
| if found == "InternalError": |
| table[row][col] = "InternalError" |
| print( |
| '#### Internal error from ParseSVError - see "%s"' |
| % output_filename |
| ) |
| elif not found: |
| table[row][col] = "ParseSVError" |
| print('#### Error from ParseSVError - see "%s"' % output_filename) |
| else: |
| table[row][col] = "NA" |
| if os.path.isfile(output_filename): |
| os.unlink(output_filename) |
| continue |
| |
| parse_result = ParseSigs(output, "SV_" + sv) |
| if parse_result: |
| separate_reg, as_arb = parse_result |
| if as_arb: |
| if separate_reg: |
| table[row][col] = "Error: both as_arb and separate_reg set!" |
| print( |
| '#### Error from ParseSigs, both as_arb and separate_reg set - see "%s"' |
| % output_filename |
| ) |
| continue |
| result = "Arb" |
| else: |
| if separate_reg: |
| result = "NotPacked" |
| else: |
| result = "SV" |
| if os.path.isfile(output_filename): |
| os.unlink(output_filename) |
| else: |
| print('## Not in signature? See "%s"' % output_filename) |
| |
| if arb_supported and not as_arb and not separate_reg: |
| output_filename = "output\\test_sv_output_last_%s_%s_%s.txt" % ( |
| sm, |
| sv, |
| sigpoint, |
| ) |
| # must system value be declared last? test by adding arb last if arb support |
| ret, output = run( |
| 'fxc %s /E %s /T %s /D%s_Defs="Def_%s Def_Arb(float,Arb1,Arb1)"' |
| % (hlsl_filename, entry, target, sigpoint, sv), |
| output_filename, |
| ) |
| if ret: |
| found = ParseSGVError(output, "SV_" + sv) |
| if found == "InternalError": |
| result += " | InternalError found with ParseSGVError" |
| print( |
| '#### Internal error from ParseSGVError - see "%s"' |
| % output_filename |
| ) |
| elif not found: |
| result += " | ParseSGVError" |
| print( |
| '#### Error from ParseSGVError - see "%s"' % output_filename |
| ) |
| elif result == "SV": |
| result = "SGV" |
| if os.path.isfile(output_filename): |
| os.unlink(output_filename) |
| else: |
| result += " | Error: last required detected, but not SV?" |
| print( |
| '#### Error: last required detected, but not SV? - see "%s"' |
| % output_filename |
| ) |
| else: |
| if os.path.isfile(output_filename): |
| os.unlink(output_filename) |
| |
| table[row][col] = result |
| |
| for row in range(row + 1, len(SysValues)): |
| table[row][col] = "TessFactor" |
| |
| def WriteTable(writefn, table): |
| writefn( |
| "Semantic," |
| + ",".join([sigpoint for sigpoint, stage, tfpresent in SignaturePoints]) |
| + "\n" |
| ) |
| for n, row in enumerate(table): |
| writefn((SysValues[n]) + ",".join(row) + "\n") |
| |
| WriteTable(sys.stdout.write, table) |
| with open("fxc_sig_packing_table_%s.csv" % sm, "wt") as f: |
| WriteTable(f.write, table) |
| |
| |
| if __name__ == "__main__": |
| main() |
