| # 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() |
