Add HLSL 2017 (-HV 2017) option. (#245)

- Fix detection of invalid options in dxcompilerobj

include/dxc/Support/HLSLOptions.h

@@ -125,6 +125,7 @@ public:
   bool EnableStrictMode;     // OPT_Ges
   bool HLSL2015;  // OPT_hlsl_version (=2015)
   bool HLSL2016;  // OPT_hlsl_version (=2016)
+  bool HLSL2017;  // OPT_hlsl_version (=2017)
   bool OptDump; // OPT_ODump - dump optimizer commands
   bool OutputWarnings = true; // OPT_no_warnings
   bool ShowHelp = false;  // OPT_help

include/dxc/Support/HLSLOptions.td

@@ -222,7 +222,7 @@ def pack_prefix_stable : Flag<["-", "/"], "pack_prefix_stable">, Group<hlslcomp_
 def pack_optimized : Flag<["-", "/"], "pack_optimized">, Group<hlslcomp_Group>, Flags<[CoreOption]>,
   HelpText<"Optimize signature packing assuming identical signature provided for each connecting stage">;
 def hlsl_version : Separate<["-", "/"], "HV">, Group<hlslcomp_Group>, Flags<[CoreOption]>,
-  HelpText<"HLSL version (Only supports 2016 for now)">;
+  HelpText<"HLSL version (2016, 2017)">;
 def no_warnings : Flag<["-", "/"], "no-warnings">, Group<hlslcomp_Group>, Flags<[CoreOption]>,
   HelpText<"Suppress warnings">;
 def rootsig_define : Separate<["-", "/"], "rootsig-define">, Group<hlslcomp_Group>, Flags<[CoreOption]>,

lib/DxcSupport/HLSLOptions.cpp

@@ -221,22 +221,19 @@ int ReadDxcOpts(const OptTable *optionTable, unsigned flagsToInclude,
 
   opts.TargetProfile = Args.getLastArgValue(OPT_target_profile);
 
-  llvm::StringRef hlslVersion = Args.getLastArgValue(OPT_hlsl_version);
-  if (hlslVersion.empty() || hlslVersion == "2016") {
-    opts.HLSL2016 = true;
-  }
-  else if (hlslVersion == "2015") {
-    opts.HLSL2016 = false;
-    if (!(flagsToInclude & HlslFlags::ISenseOption)) {
-      errors << "HLSL Version 2015 is only supported for language services";
-      return 1;
-    }
-  }
+  llvm::StringRef ver = Args.getLastArgValue(OPT_hlsl_version);
+  opts.HLSL2015 = opts.HLSL2016 = opts.HLSL2017 = false;
+  if (ver.empty() || ver == "2016") { opts.HLSL2016 = true; }   // Default to 2016
+  else if           (ver == "2015") { opts.HLSL2015 = true; }
+  else if           (ver == "2017") { opts.HLSL2017 = true; }
   else {
     errors << "Unknown HLSL version";
     return 1;
   }
-  opts.HLSL2015 = !opts.HLSL2016;
+  if (opts.HLSL2015 && !(flagsToInclude & HlslFlags::ISenseOption)) {
+    errors << "HLSL Version 2015 is only supported for language services";
+    return 1;
+  }
 
   // AssemblyCodeHex not supported (Fx)
   // OutputLibrary not supported (Fl)

tools/clang/include/clang/Basic/LangOptions.h

@@ -151,6 +151,7 @@ public:
   // MS Change Starts
   bool HLSL2015;  // Only supported for IntelliSense scenarios.
   bool HLSL2016;
+  bool HLSL2017;
   std::string HLSLEntryFunction;
   unsigned RootSigMajor;
   unsigned RootSigMinor;

tools/clang/include/clang/Driver/Options.td

@@ -677,7 +677,7 @@ def fms_volatile : Joined<["-"], "fms-volatile">, Group<f_Group>, Flags<[CC1Opti
 def fmsc_version : Joined<["-"], "fmsc-version=">, Group<f_Group>, Flags<[DriverOption, CoreOption]>,
   HelpText<"Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))">;
 def hlsl_version : Separate<["-", "/"], "HV">, Group<f_Group>, Flags<[DriverOption, CoreOption, CC1Option]>,
-  HelpText<"HLSL version (2015, 2016)">; // HLSL Change - mimic the HLSLOptions.td flag
+  HelpText<"HLSL version (2015, 2016, 2017)">; // HLSL Change - mimic the HLSLOptions.td flag
 def fms_compatibility_version
     : Joined<["-"], "fms-compatibility-version=">,
       Group<f_Group>,

tools/clang/lib/Frontend/CompilerInvocation.cpp

@@ -1721,13 +1721,15 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
   Opts.SanitizerBlacklistFiles = Args.getAllArgValues(OPT_fsanitize_blacklist);
 #else
   StringRef ver = Args.getLastArgValue(OPT_hlsl_version);
-  if (ver.empty() || ver == "2016") {
-    Opts.HLSL2016 = true;
-  }
+  Opts.HLSL2015 = Opts.HLSL2016 = Opts.HLSL2017 = false;
+  if (ver.empty() || ver == "2016") { Opts.HLSL2016 = true; }   // Default to 2016
+  else if           (ver == "2015") { Opts.HLSL2015 = true; }
+  else if           (ver == "2017") { Opts.HLSL2017 = true; }
   else {
-    Opts.HLSL2016 = false;
+    Diags.Report(diag::err_drv_invalid_value)
+      << Args.getLastArg(OPT_hlsl_version)->getAsString(Args)
+      << ver;
   }
-  Opts.HLSL2015 = !Opts.HLSL2016;
 #endif // #ifdef MS_SUPPORT_VARIABLE_LANGOPTS
 }
 

tools/clang/tools/dxcompiler/dxcompilerobj.cpp

@@ -1994,10 +1994,12 @@ private:
       CComPtr<IDxcBlob> pErrorBlob;
       IFT(pOutputStream->QueryInterface(&pErrorBlob));
       CComPtr<IDxcBlobEncoding> pErrorBlobWithEncoding;
+      outStream.flush();
       IFT(DxcCreateBlobWithEncodingSet(pErrorBlob.p, CP_UTF8,
                                        &pErrorBlobWithEncoding));
       IFT(DxcOperationResult::CreateFromResultErrorStatus(nullptr, pErrorBlobWithEncoding.p, E_INVALIDARG, ppResult));
       finished = true;
+      return;
     }
     DXASSERT(!opts.HLSL2015, "else ReadDxcOpts didn't fail for non-isense");
     finished = false;

tools/clang/unittests/HLSL/CompilerTest.cpp

@@ -298,6 +298,11 @@ public:
   TEST_METHOD(CompileWhenRecursiveAlbeitStaticTermThenFail)
   TEST_METHOD(CompileWhenRecursiveThenFail)
 
+  TEST_METHOD(CompileHlsl2015ThenFail)
+  TEST_METHOD(CompileHlsl2016ThenOK)
+  TEST_METHOD(CompileHlsl2017ThenOK)
+  TEST_METHOD(CompileHlsl2018ThenFail)
+
   TEST_METHOD(CodeGenAbs1)
   TEST_METHOD(CodeGenAbs2)
   TEST_METHOD(CodeGenAllLit)
@@ -2033,6 +2038,87 @@ TEST_F(CompilerTest, CompileWhenRecursiveThenFail) {
   VerifyCompileFailed(ShaderTextMissing, L"vs_6_0", "missing entry point definition");
 }
 
+TEST_F(CompilerTest, CompileHlsl2015ThenFail) {
+  CComPtr<IDxcCompiler> pCompiler;
+  CComPtr<IDxcOperationResult> pResult;
+  CComPtr<IDxcBlobEncoding> pSource;
+  CComPtr<IDxcBlobEncoding> pErrors;
+
+  VERIFY_SUCCEEDED(CreateCompiler(&pCompiler));
+  CreateBlobFromText("float4 main(float4 pos : SV_Position) : SV_Target { return pos; }", &pSource);
+
+  LPCWSTR args[2] = { L"-HV", L"2015" };
+
+  VERIFY_SUCCEEDED(pCompiler->Compile(pSource, L"source.hlsl", L"main",
+    L"ps_6_0", args, 2, nullptr, 0, nullptr, &pResult));
+
+  HRESULT status;
+  VERIFY_SUCCEEDED(pResult->GetStatus(&status));
+  VERIFY_ARE_EQUAL(status, E_INVALIDARG);
+  VERIFY_SUCCEEDED(pResult->GetErrorBuffer(&pErrors));
+  LPCSTR pErrorMsg = "HLSL Version 2015 is only supported for language services";
+  CheckOperationResultMsgs(pResult, &pErrorMsg, 1, false, false);
+}
+
+TEST_F(CompilerTest, CompileHlsl2016ThenOK) {
+  CComPtr<IDxcCompiler> pCompiler;
+  CComPtr<IDxcOperationResult> pResult;
+  CComPtr<IDxcBlobEncoding> pSource;
+  CComPtr<IDxcBlobEncoding> pErrors;
+
+  VERIFY_SUCCEEDED(CreateCompiler(&pCompiler));
+  CreateBlobFromText("float4 main(float4 pos : SV_Position) : SV_Target { return pos; }", &pSource);
+
+  LPCWSTR args[2] = { L"-HV", L"2016" };
+
+  VERIFY_SUCCEEDED(pCompiler->Compile(pSource, L"source.hlsl", L"main",
+    L"ps_6_0", args, 2, nullptr, 0, nullptr, &pResult));
+
+  HRESULT status;
+  VERIFY_SUCCEEDED(pResult->GetStatus(&status));
+  VERIFY_SUCCEEDED(status);
+}
+
+TEST_F(CompilerTest, CompileHlsl2017ThenOK) {
+  CComPtr<IDxcCompiler> pCompiler;
+  CComPtr<IDxcOperationResult> pResult;
+  CComPtr<IDxcBlobEncoding> pSource;
+  CComPtr<IDxcBlobEncoding> pErrors;
+
+  VERIFY_SUCCEEDED(CreateCompiler(&pCompiler));
+  CreateBlobFromText("float4 main(float4 pos : SV_Position) : SV_Target { return pos; }", &pSource);
+
+  LPCWSTR args[2] = { L"-HV", L"2017" };
+
+  VERIFY_SUCCEEDED(pCompiler->Compile(pSource, L"source.hlsl", L"main",
+    L"ps_6_0", args, 2, nullptr, 0, nullptr, &pResult));
+
+  HRESULT status;
+  VERIFY_SUCCEEDED(pResult->GetStatus(&status));
+  VERIFY_SUCCEEDED(status);
+}
+
+TEST_F(CompilerTest, CompileHlsl2018ThenFail) {
+  CComPtr<IDxcCompiler> pCompiler;
+  CComPtr<IDxcOperationResult> pResult;
+  CComPtr<IDxcBlobEncoding> pSource;
+  CComPtr<IDxcBlobEncoding> pErrors;
+
+  VERIFY_SUCCEEDED(CreateCompiler(&pCompiler));
+  CreateBlobFromText("float4 main(float4 pos : SV_Position) : SV_Target { return pos; }", &pSource);
+
+  LPCWSTR args[2] = { L"-HV", L"2018" };
+
+  VERIFY_SUCCEEDED(pCompiler->Compile(pSource, L"source.hlsl", L"main",
+    L"ps_6_0", args, 2, nullptr, 0, nullptr, &pResult));
+
+  HRESULT status;
+  VERIFY_SUCCEEDED(pResult->GetStatus(&status));
+  VERIFY_ARE_EQUAL(status, E_INVALIDARG);
+  VERIFY_SUCCEEDED(pResult->GetErrorBuffer(&pErrors));
+  LPCSTR pErrorMsg = "Unknown HLSL version";
+  CheckOperationResultMsgs(pResult, &pErrorMsg, 1, false, false);
+}
 
 TEST_F(CompilerTest, CodeGenAbs1) {
   CodeGenTestCheck(L"..\\CodeGenHLSL\\abs1.hlsl");