commit a6a7842fdbf5e5781786a82ede91771fe5d2c31c
author Jiawei Shao <jiawei.shao@intel.com> Thu Jun 28 08:32:54 2018 +0800
committer Commit Bot <commit-bot@chromium.org> Wed Jul 11 07:33:59 2018 +0000
tree 983ea2377ac98f0e085e2bcf4459e10288fc67c7
parent a2f043d847dd7ca53ea43c78b79e8709923d7a4d

ES31: Support atomic functions on D3D11 - Part I

This patch is the first one of the implementation of atomic
functions in D3D11.

There are mainly two differences in the usage of GLSL and HLSL
atomic functions:
1. All GLSL atomic functions have return values, which all
   represent the original value of the shared or ssbo variable;
   while all HLSL atomic functions don't, and the original value
   can be stored in the last parameter of the function call.
2. For HLSL atomic functions, the last parameter that stores the
   original value is optional except for InterlockedExchange and
   InterlockedCompareExchange. Missing original_value in the call
   of InterlockedExchange and InterlockedCompareExchange results
   in a compile error from HLSL compiler.

To handle these differences, we plan to implement the translation
in two steps:
1. Support direct translations from GLSL atomic functions to HLSL
   ones.
Direct translation can only handle the following two situations:
(1) The sentence is a GLSL atomic function call without requesting
    a return value and it is not atomicExchange or atomicCompSwap:
    e.g.
    GLSL: atomicAdd(mem, value);
 -> HLSL: InterlockedAdd(mem, value);
(2) The sentence is a simple assignment expression: its right is
    a GLSL atomic function call and its left is a declared variable.
    e.g.
    GLSL: oldValue = atomicAdd(mem, value);
 -> HLSL: InterlockedAdd(mem, value, oldValue);

2. Support atomic functions in the situations that don't support
   direct translations.
We will modify the intermediate tree to make direct translation work
on all these situations.
e.g.
   atomicExchange(mem, value);
-> int oldValue;
   oldValue = atomicExchange(mem, value);

   int oldValue = atomicAdd(mem, value);
-> int oldValue;
   oldValue = atomicAdd(mem, value);

   return atomicAdd(mem, value);
-> int temp;
   temp = atomicAdd(mem, value);
   return temp;

   for (i = 0; i < atomicAdd(mem, value); ++i)
-> int temp;
   temp = atomicAdd(mem, value);
   for (i = 0; i < temp; ++i)
   {
       ...
       temp = atomicAdd(mem, value);
   }

   int result = isTrue ? atomicAdd(mem, value) : 0;
-> int result;
   if (isTrue)
   {
       result = atomicAdd(mem, value);
   }
   else
   {
       result = 0;
   }

This patch completes Step 1 which mainly focus on the translation
from GLSL atomic functions to HLSL ones.

BUG=angleproject:2682
TEST=angle_end2end_tests

Change-Id: I3b655b6e286dad4fd97f255f7fe87521c94db30c
Reviewed-on: https://chromium-review.googlesource.com/1121835
Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
Reviewed-by: Olli Etuaho <oetuaho@nvidia.com>

src/compiler/translator/ParseContext.cpp

diff --git a/src/compiler/translator/ParseContext.cpp b/src/compiler/translator/ParseContext.cpp
index e387575..7ce9acc 100644
--- a/src/compiler/translator/ParseContext.cpp
+++ b/src/compiler/translator/ParseContext.cpp
@@ -5620,10 +5620,10 @@
 
 void TParseContext::checkAtomicMemoryBuiltinFunctions(TIntermAggregate *functionCall)
 {
-    ASSERT(functionCall->getOp() == EOpCallBuiltInFunction);
     const TFunction *func = functionCall->getFunction();
     if (BuiltInGroup::isAtomicMemory(func))
     {
+        ASSERT(IsAtomicFunction(functionCall->getOp()));
         TIntermSequence *arguments = functionCall->getSequence();
         TIntermTyped *memNode      = (*arguments)[0]->getAsTyped();
 
@@ -5845,10 +5845,13 @@
                     ASSERT(callNode != nullptr);
                     return callNode;
                 }
+
                 TIntermAggregate *callNode =
                     TIntermAggregate::CreateBuiltInFunctionCall(*fnCandidate, &fnCall->arguments());
                 callNode->setLine(loc);
 
+                checkAtomicMemoryBuiltinFunctions(callNode);
+
                 // Some built-in functions have out parameters too.
                 functionCallRValueLValueErrorCheck(fnCandidate, callNode);
 
@@ -5864,7 +5867,6 @@
             checkTextureOffsetConst(callNode);
             checkTextureGather(callNode);
             checkImageMemoryAccessForBuiltinFunctions(callNode);
-            checkAtomicMemoryBuiltinFunctions(callNode);
             functionCallRValueLValueErrorCheck(fnCandidate, callNode);
             return callNode;
         }