HLSL backend: work around FXC ignoring switch with only default case

In HLSL code, if a switch statement has only a default case, FXC will
effectively ignore the code in that case. In this change, we detect this
and work around it by emitting the code in the default block without the
switch.

Bug: tint:1188
Change-Id: I69b405cdb4c669fb093eb49aa138923419dcf8f8
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/68440
Kokoro: Antonio Maiorano <amaiorano@google.com>
Commit-Queue: Antonio Maiorano <amaiorano@google.com>
Reviewed-by: Ben Clayton <bclayton@chromium.org>

src/writer/hlsl/generator_impl.cc

@@ -2948,7 +2948,44 @@ bool GeneratorImpl::EmitStatement(const ast::Statement* stmt) {
   return false;
 }
 
+bool GeneratorImpl::EmitDefaultOnlySwitch(const ast::SwitchStatement* stmt) {
+  TINT_ASSERT(Writer, stmt->body.size() == 1 && stmt->body[0]->IsDefault());
+
+  // FXC fails to compile a switch with just a default case, ignoring the
+  // default case body. We work around this here by emitting the default case
+  // without the switch.
+
+  // Emit the switch condition as-is in case it has side-effects (e.g.
+  // function call). Note that's it's fine not to assign the result of the
+  // expression.
+  {
+    auto out = line();
+    if (!EmitExpression(out, stmt->condition)) {
+      return false;
+    }
+    out << ";";
+  }
+
+  // Emit "do { <default case body> } while(false);". We use a 'do' loop so
+  // that break statements work as expected, and make it 'while (false)' in
+  // case there isn't a break statement.
+  line() << "do {";
+  {
+    ScopedIndent si(this);
+    if (!EmitStatements(stmt->body[0]->body->statements)) {
+      return false;
+    }
+  }
+  line() << "} while (false);";
+  return true;
+}
+
 bool GeneratorImpl::EmitSwitch(const ast::SwitchStatement* stmt) {
+  // BUG(crbug.com/tint/1188): work around default-only switches
+  if (stmt->body.size() == 1 && stmt->body[0]->IsDefault()) {
+    return EmitDefaultOnlySwitch(stmt);
+  }
+
   {  // switch(expr) {
     auto out = line();
     out << "switch(";

src/writer/hlsl/generator_impl.h

@@ -327,6 +327,10 @@ class GeneratorImpl : public TextGenerator {
   /// @param stmt the statement to emit
   /// @returns true if the statement was emitted
   bool EmitSwitch(const ast::SwitchStatement* stmt);
+  // Handles generating a switch statement with only a default case
+  /// @param stmt the statement to emit
+  /// @returns true if the statement was emitted
+  bool EmitDefaultOnlySwitch(const ast::SwitchStatement* stmt);
   /// Handles generating type
   /// @param out the output stream
   /// @param type the type to generate

src/writer/hlsl/generator_impl_switch_test.cc

@@ -23,23 +23,10 @@ using HlslGeneratorImplTest_Switch = TestHelper;
 
 TEST_F(HlslGeneratorImplTest_Switch, Emit_Switch) {
   Global("cond", ty.i32(), ast::StorageClass::kPrivate);
-
-  auto* def_body = Block(create<ast::BreakStatement>());
-  auto* def = create<ast::CaseStatement>(ast::CaseSelectorList{}, def_body);
-
-  ast::CaseSelectorList case_val;
-  case_val.push_back(Literal(5));
-
-  auto* case_body = Block(create<ast::BreakStatement>());
-
-  auto* case_stmt = create<ast::CaseStatement>(case_val, case_body);
-
-  ast::CaseStatementList body;
-  body.push_back(case_stmt);
-  body.push_back(def);
-
-  auto* cond = Expr("cond");
-  auto* s = create<ast::SwitchStatement>(cond, body);
+  auto* s = Switch(                      //
+      Expr("cond"),                      //
+      Case(Literal(5), Block(Break())),  //
+      DefaultCase());
   WrapInFunction(s);
 
   GeneratorImpl& gen = Build();
@@ -58,6 +45,26 @@ TEST_F(HlslGeneratorImplTest_Switch, Emit_Switch) {
 )");
 }
 
+TEST_F(HlslGeneratorImplTest_Switch, Emit_Switch_OnlyDefaultCase) {
+  Global("cond", ty.i32(), ast::StorageClass::kPrivate);
+  Global("a", ty.i32(), ast::StorageClass::kPrivate);
+  auto* s = Switch(  //
+      Expr("cond"),  //
+      DefaultCase(Block(Assign(Expr("a"), Expr(42)))));
+  WrapInFunction(s);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(s)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  cond;
+  do {
+    a = 42;
+  } while (false);
+)");
+}
+
 }  // namespace
 }  // namespace hlsl
 }  // namespace writer